9/1/21 update

198.house-robber.cpp

+/*
+ * @lc app=leetcode id=198 lang=cpp
+ *
+ * [198] House Robber
+ */
+
+// @lc code=start
+class Solution
+{
+public:
+    int rob(vector<int> &nums)
+    {
+        //时间序列dp
+        // dp[i][j] <= 第i轮 第j种状态
+        // 0: the max money without rob this house
+        // 1: the max money rob this house
+        vector<vector<int>> dp(nums.size(), vector<int>(2, 0));
+        dp[0][1] = nums[0];
+        const int n = nums.size();
+        for (int i = 1; i < nums.size(); ++i)
+        {
+            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
+            dp[i][1] = dp[i - 1][0] + nums[i];
+        } //for
+
+        return max(dp[n - 1][0], dp[n - 1][1]);
+    }
+};
+// @lc code=end

200.number-of-islands.cpp

+/*
+ * @lc app=leetcode id=200 lang=cpp
+ *
+ * [200] Number of Islands
+ */
+
+// @lc code=start
+class Solution
+{
+    vector<pair<int, int>> dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+public:
+    int numIslands(vector<vector<char>> &grid)
+    {
+        // either bfs ad dfs works
+        // this is the bfs solution
+
+        const int m = grid.size();
+        if (m == 0)
+            return 0;
+        const int n = grid[0].size();
+
+        int count = 0;
+
+        // find the next 1
+        for (int i = 0; i < m; ++i)
+        {
+            for (int j = 0; j < n; ++j)
+            {
+                if (grid[i][j] == '1')
+                {
+                    count += 1;
+
+                    //do bfs here
+                    queue<pair<int, int>> q; //{pos}
+                    q.push({i, j});
+                    grid[i][j] = '#';
+
+                    while (!q.empty())
+                    {
+                        auto [curr_x, curr_y] = q.front();
+                        q.pop();
+
+                        for (auto &dir : dirs)
+                        {
+                            int n_x = curr_x + dir.first;
+                            int n_y = curr_y + dir.second;
+
+                            if (n_x < 0 || n_y < 0 || n_x >= m || n_y >= n)
+                                continue;
+
+                            if (grid[n_x][n_y] != '1')
+                                continue;
+
+                            q.push({n_x, n_y});
+                            grid[n_x][n_y] = '#';
+                        } //for
+                    }     //while
+                }
+            } //for
+        }     //for
+
+        return count;
+    }
+};
+// @lc code=end

213.house-robber-ii.cpp

+/*
+ * @lc app=leetcode id=213 lang=cpp
+ *
+ * [213] House Robber II
+ */
+
+// @lc code=start
+class Solution
+{
+public:
+    int rob(vector<int> &nums)
+    {
+        int n = nums.size();
+        vector<vector<int>> dp1();
+        vector<vector<int>> dp2();
+    }
+};
+// @lc code=end

282.expression-add-operators.cpp

+/*
+ * @lc app=leetcode id=282 lang=cpp
+ *
+ * [282] Expression Add Operators
+ */
+
+// @lc code=start
+class Solution
+{
+    vector<string> res;
+
+public:
+    vector<string> addOperators(string num, int target)
+    {
+        // 这题很多细节
+        string currExp = "";
+        long long currRes = 0;
+        int curr = 0;
+        dfs(num, target, curr, currRes, currExp, currRes);
+        return res;
+    }
+
+    void dfs(string &num, int target, int curr,
+             long long currRes, string currExp, long long lastTerm)
+    {
+        if (curr == num.size())
+        {
+            if (currRes == target)
+                res.push_back(currExp);
+            return;
+        }
+
+        for (int i = curr; i < num.size(); ++i)
+        {
+            string currNumS = num.substr(curr, i - curr + 1);
+            if (currNumS.size() > 1 && currNumS[0] == '0')
+                continue;
+
+            long long currNum = stoll(currNumS);
+
+            if (curr == 0)
+                dfs(num, target, curr + currNumS.size(),
+                    currRes + currNum,
+                    currExp + currNumS, currNum);
+            else
+            {
+                dfs(num, target, curr + currNumS.size(),
+                    currRes + currNum,
+                    currExp + "+" + currNumS, currNum);
+                dfs(num, target, curr + currNumS.size(),
+                    currRes - currNum,
+                    currExp + "-" + currNumS, -currNum); //notice, turn to minus
+                dfs(num, target, curr + currNumS.size(),
+                    currRes - lastTerm + lastTerm * currNum,
+                    currExp + "*" + currNumS, lastTerm * currNum);
+            }
+        }
+    } //dfs()
+};
+// @lc code=end
+
+//123 + 4 * dfs(...)
+
+//
\ No newline at end of file

301.remove-invalid-parentheses.cpp

+/*
+ * @lc app=leetcode id=301 lang=cpp
+ *
+ * [301] Remove Invalid Parentheses
+ */
+
+// @lc code=start
+class Solution
+{
+    vector<string> rets;
+    int retLen;
+
+public:
+    vector<string> removeInvalidParentheses(string s)
+    {
+        string curStr = "";
+        retLen = -1;
+
+        dfs(curStr, s, 0, 0);
+        return rets;
+    }
+
+    void dfs(string curStr, string &s, int i, int count)
+    {
+        if (count < 0)
+            return;
+
+        if (i == s.size())
+        {
+            if (count != 0)
+                return;
+
+            if (curStr.size() == retLen)
+                rets.push_back(curStr);
+            else if ((int)curStr.size() > retLen)
+            {
+                rets.clear();
+                rets.push_back(curStr);
+                retLen = curStr.size();
+            }
+            return;
+        }
+
+        if (s[i] != '(' && s[i] != ')')
+        {
+            dfs(curStr + s.substr(i, 1), s, i + 1, count);
+            return;
+        }
+
+        dfs(curStr + s.substr(i, 1), s, i + 1, count + (s[i] == '(' ? 1 : -1));
+
+        if (curStr.size() == 0 || curStr.back() != s[i])
+            dfs(curStr, s, i + 1, count);
+    }
+};
+// @lc code=end

312.burst-balloons.cpp

+/*
+ * @lc app=leetcode id=312 lang=cpp
+ *
+ * [312] Burst Balloons
+ */
+
+// @lc code=start
+class Solution
+{
+public:
+    int maxCoins(vector<int> &nums)
+    {
+        int n = nums.size();
+        nums.insert(nums.begin(), 1);
+        nums.push_back(1);
+
+        auto dp = vector<vector<int>>(n + 2, vector<int>(n + 2, 0));
+
+        for (int len = 1; len <= n; len++)
+            for (int i = 1; i + len - 1 <= n; i++)
+            {
+                int j = i + len - 1;
+                for (int k = i; k <= j; k++)
+                    dp[i][j] = max(
+                        dp[i][j],
+                        dp[i][k - 1] + dp[k + 1][j] + nums[i - 1] * nums[k] * nums[j + 1]);
+            }
+
+        return dp[1][n];
+    }
+};
+// @lc code=end
+
+// [1 x i xxx j]
\ No newline at end of file

473.matchsticks-to-square.cpp

+/*
+ * @lc app=leetcode id=473 lang=cpp
+ *
+ * [473] Matchsticks to Square
+ */
+
+// @lc code=start
+class Solution
+{
+    int total = 0;
+
+public:
+    bool makesquare(vector<int> &matchsticks)
+    {
+        // more general: partition in k equ sum subsets
+        // we add stick one by one group by one group
+        total = accumulate(matchsticks.begin(), matchsticks.end(), 0);
+        if (total % 4 != 0)
+            return false;
+
+        sort(matchsticks.begin(), matchsticks.end());
+        reverse(matchsticks.begin(), matchsticks.end()); // greedy
+
+        vector<bool> visited(15, false); // at max 15 sticks
+        return dfs(matchsticks, visited, 0, 0, 0);
+    }
+
+    bool dfs(vector<int> &matchsticks, vector<bool> &visited,
+             int curr, int currGrp, int currGrpSum)
+    {
+        if (currGrp == 4)
+            return true;
+        if (currGrpSum > total / 4)
+            return false;
+        if (currGrpSum == total / 4)
+            return dfs(matchsticks, visited, 0, currGrp + 1, 0);
+
+        for (int i = curr; i < matchsticks.size(); ++i)
+        {
+            if (visited[i])
+                continue;
+            visited[i] = true;
+            if (dfs(matchsticks, visited,
+                    i + 1, currGrp,
+                    currGrpSum + matchsticks[i]))
+                return true;
+            visited[i] = false;
+        } //for
+
+        return false;
+    }
+};
+// @lc code=end

491.increasing-subsequences.cpp

+/*
+ * @lc app=leetcode id=491 lang=cpp
+ *
+ * [491] Increasing Subsequences
+ */
+
+// @lc code=start
+class Solution
+{
+public:
+    vector<vector<int>> findSubsequences(vector<int> &nums)
+    {
+    }
+};
+// @lc code=end

698.partition-to-k-equal-sum-subsets.cpp

+/*
+ * @lc app=leetcode id=698 lang=cpp
+ *
+ * [698] Partition to K Equal Sum Subsets
+ */
+
+// @lc code=start
+class Solution
+{
+    int total = 0;
+    int k = 0;
+
+public:
+    bool canPartitionKSubsets(vector<int> &nums, int k)
+    {
+        total = accumulate(nums.begin(), nums.end(), 0);
+        this->k = k;
+        if (total % k != 0)
+            return false;
+        vector<bool> visited(16, false);
+        int curr = 0;
+        int currGrp = 0;
+        int currGrpSum = 0;
+        return dfs(nums, visited, curr, currGrp, currGrpSum);
+    }
+
+    bool dfs(vector<int> &nums, vector<bool> &visited,
+             int curr, int currGrp, int currGrpSum)
+    {
+        // pruning
+        if (currGrp == k)
+            return true;
+        if (currGrpSum > total / k)
+            return false;
+        if (currGrpSum == total / k)
+            return dfs(nums, visited, 0, currGrp + 1, 0);
+
+        for (int i = curr; i < nums.size(); ++i)
+        {
+            if (visited[i])
+                continue;
+            visited[i] = true;
+            if (dfs(nums, visited, i + 1,
+                    currGrp, currGrpSum + nums[i]))
+                return true;
+            visited[i] = false;
+        } //for
+
+        return false;
+    }
+};
+// @lc code=end

921.minimum-add-to-make-parentheses-valid.cpp

+/*
+ * @lc app=leetcode id=921 lang=cpp
+ *
+ * [921] Minimum Add to Make Parentheses Valid
+ */
+
+// @lc code=start
+class Solution
+{
+public:
+    int minAddToMakeValid(string s)
+    {
+        int count = 0;
+        int res = 0;
+        for (char ch : s)
+        {
+            if (ch == '(')
+                count++;
+            else if (ch == ')')
+                count--;
+
+            if (count < 0)
+            {
+                count++;
+                res++;
+            } // if
+        }     //for
+
+        return count + res;
+    }
+};
+// @lc code=end

958.check-completeness-of-a-binary-tree.cpp

+/*
+ * @lc app=leetcode id=958 lang=cpp
+ *
+ * [958] Check Completeness of a Binary Tree
+ */
+
+// @lc code=start
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution
+{
+public:
+    bool isCompleteTree(TreeNode *root)
+    {
+        //bfs
+        // idea: from the right to the left, if we meet one null, we shoud not see any other child
+        queue<TreeNode *> q;
+        q.push(root);
+        bool end = false;
+        while (!q.empty())
+        {
+            int len = q.size();
+            for (int i = 0; i < len; ++i)
+            {
+                TreeNode *curr = q.front();
+                q.pop();
+                if (curr->left)
+                {
+                    if (end)
+                        return false;
+                    q.push(curr->left);
+                }
+                else
+                    end = true;
+                if (curr->right)
+                {
+                    if (end)
+                        return false;
+                    q.push(curr->right);
+                }
+                else
+                    end = true;
+            } //for
+        }     //while
+
+        return true;
+    }
+};
+// @lc code=end