8 medium problems

Author: zhuli19901106

construct-binary-tree-from-inorder-and-postorder-traversal_1_AC.cpp

@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <unordered_map>
+using std::unordered_map;
+
+class Solution {
+public:
+    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
+        int n = inorder.size();
+        int i;
+        unordered_map<int, int> um;
+        for (i = 0; i < n; ++i) {
+            um[inorder[i]] = i;
+        }
+        TreeNode *root = reconstruct(inorder, postorder, 0, n - 1, 0, n - 1, um);
+        um.clear();
+        return root;
+    }
+private:
+    TreeNode* reconstruct(vector<int>& in, vector<int>& post, int l1, int r1, 
+        int l2, int r2, unordered_map<int, int>& um) {
+        if (l1 > r1) {
+            return NULL;
+        }
+        TreeNode *root = new TreeNode(post[r2]);
+        int root_idx = um[root->val];
+        int len_left = root_idx - l1;
+        int len_right = r1 - root_idx;
+        root->left = reconstruct(in, post, l1, root_idx - 1, l2, 
+            l2 + len_left - 1, um);
+        root->right = reconstruct(in, post, root_idx + 1, r1, l2 + len_left, 
+            r2 - 1, um);
+        return root;
+    }
+};

construct-binary-tree-from-preorder-and-inorder-traversal_1_AC.cpp

@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <unordered_map>
+using std::unordered_map;
+
+class Solution {
+public:
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        int n = inorder.size();
+        int i;
+        unordered_map<int, int> um;
+        for (i = 0; i < n; ++i) {
+            um[inorder[i]] = i;
+        }
+        TreeNode *root = reconstruct(preorder, inorder, 0, n - 1, 0, n - 1, um);
+        um.clear();
+        return root;
+    }
+    
+    TreeNode *reconstruct(vector<int> &pre, vector<int> &in, int l1, int r1, 
+        int l2, int r2, unordered_map<int, int> &um) {
+        if (l1 > r1) {
+            return NULL;
+        }
+        TreeNode *root = new TreeNode(pre[l1]);
+        int root_idx = um[root->val];
+        int len_left = root_idx - l2;
+        int len_right = r2 - root_idx;
+        root->left = reconstruct(pre, in, l1 + 1, l1 + len_left, l2, 
+            root_idx - 1, um);
+        root->right = reconstruct(pre, in, r1 - len_right + 1, r1, 
+            root_idx + 1, r2, um);
+        return root;
+    }
+};

max-consecutive-ones_1_AC.cpp

@@ -0,0 +1,26 @@
+#include <algorithm>
+using std::max;
+
+class Solution {
+public:
+    int findMaxConsecutiveOnes(vector<int>& nums) {
+        int n = nums.size();
+        int i, j;
+        int res = 0;
+        
+        i = 0;
+        while (i < n) {
+            if (nums[i] == 0) {
+                ++i;
+                continue;
+            }
+            j = i + 1;
+            while (j < n && nums[j] == 1) { 
+                ++j;
+            }
+            res = max(res, j - i);
+            i = j;
+        }
+        return res;
+    }
+};

palindrome-partitioning_1_AC.cpp

@@ -0,0 +1,46 @@
+class Solution {
+public:
+    vector<vector<string>> partition(string s) {
+        int ls = s.size();
+        vector<vector<string>> res;
+        if (ls == 0) {
+            return res;
+        }
+        
+        vector<vector<bool>> is_pal(ls, vector<bool>(ls, false));
+        int i, j;
+        for (i = 0; i < ls; ++i) {
+            is_pal[i][i] = true;
+        }
+        for (i = 0; i < ls - 1; ++i) {
+            is_pal[i][i + 1] = (s[i] == s[i + 1]);
+        }
+        for (i = 2; i < ls; ++i) {
+            for (j = 0; j + i < ls; ++j) {
+                is_pal[j][j + i] = (is_pal[j + 1][j + i - 1] && 
+                    (s[j] == s[j + i]));
+            }
+        }
+        vector<string> v;
+        dfs(0, v, s, res, is_pal);
+        return res;
+    }
+private:
+    void dfs(int idx, vector<string> &v, string &s, vector<vector<string>> &res, 
+        vector<vector<bool>> &is_pal) {
+        int ls = s.size();
+        if (idx == ls) {
+            res.push_back(v);
+            return;
+        }
+        int i;
+        for (i = idx; i < ls; ++i) {
+            if (!is_pal[idx][i]) {
+                continue;
+            }
+            v.push_back(s.substr(idx, i - idx + 1));
+            dfs(i + 1, v, s, res, is_pal);
+            v.pop_back();
+        }
+    }
+};

permutations-ii_1_AC.cpp

@@ -0,0 +1,40 @@
+#include <algorithm>
+using std::reverse;
+using std::sort;
+using std::swap;
+
+class Solution {
+public:
+    vector<vector<int>> permuteUnique(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        int n = nums.size();
+        vector<vector<int>> res;
+        do {
+            res.push_back(nums);
+        } while (nextPermutation(nums, 0, n - 1));
+        return res;
+    }
+private:
+    bool nextPermutation(vector<int> &v, int left, int right) {
+        if (left >= right) {
+            return false;
+        }
+        
+        int i, j;
+        i = right - 1;
+        while (i >= left && v[i] >= v[i + 1]) {
+            --i;
+        }
+        if (i < left) {
+            return false;
+        }
+        
+        j = right;
+        while (v[i] >= v[j]) {
+            --j;
+        }
+        swap(v[i], v[j]);
+        reverse(v.begin() + i + 1, v.begin() + right + 1);
+        return true;
+    }
+};

search-for-a-range_1_AC.cpp

@@ -0,0 +1,18 @@
+#include <algorithm>
+using std::lower_bound;
+using std::upper_bound;
+
+class Solution {
+public:
+    vector<int> searchRange(vector<int>& nums, int target) {
+        vector<int> res(2, -1);
+        int n = nums.size();
+        int pos = lower_bound(nums.begin(), nums.end(), target) - nums.begin();
+        if (pos == n || nums[pos] > target) {
+            return res;
+        }
+        res[0] = pos;
+        res[1] = upper_bound(nums.begin(), nums.end(), target) - nums.begin() - 1;
+        return res;
+    }
+};

unique-binary-search-trees-ii_1_AC.cpp

@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<TreeNode*> generateTrees(int n) {
+        vector<TreeNode *> res;
+        if (n == 0) {
+            return res;
+        }
+        dfs(1, n, res);
+        return res;
+    }
+private:
+    void dfs(int left, int right, vector<TreeNode *> &res) {
+        if (left > right) {
+            res.push_back(NULL);
+            return;
+        }
+        int i, j, k;
+        vector<TreeNode *> left_res, right_res;
+        TreeNode *root;
+        int nl, nr;
+        for (i = left; i <= right; ++i) {
+            dfs(left, i - 1, left_res);
+            dfs(i + 1, right, right_res);
+            nl = left_res.size();
+            nr = right_res.size();
+            for (j = 0; j < nl; ++j) {
+                for (k = 0; k < nr; ++k) {
+                    root = new TreeNode(i);
+                    root->left = left_res[j];
+                    root->right = right_res[k];
+                    res.push_back(root);
+                }
+            }
+            left_res.clear();
+            right_res.clear();
+        }
+    }
+};

unique-paths-ii_1_AC.cpp

@@ -0,0 +1,32 @@
+// Leetcode has just added integer overflow detection, so watch out.
+#include <cstdint>
+
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int n = obstacleGrid.size();
+        int m = (n > 0 ? obstacleGrid[0].size() : 0);
+        if (n == 0 || m == 0) {
+            return 0;
+        }
+        
+        vector<vector<int64_t>> dp(2, vector<int64_t>(m + 1));
+        int i, j;
+        int f, nf;
+        
+        dp[0][1] = 1;
+        f = 1;
+        nf = 1 - f;
+        for (i = 0; i < n; ++i) {
+            dp[f][0] = 0;
+            for (j = 0; j < m; ++j) {
+                dp[f][j + 1] = (obstacleGrid[i][j] == 0 ? dp[nf][j + 1] + dp[f][j] : 0);
+            }
+            f = 1 - f;
+            nf = 1 - f;
+        }
+        int res = dp[nf][m];
+        dp.clear();
+        return res;
+    }
+};