[ { "path": ".gitignore", "content": "# Compiled Object files\n*.slo\n*.lo\n*.o\n\n# Compiled Dynamic libraries\n*.so\n*.dylib\n\n# Compiled Static libraries\n*.lai\n*.la\n*.a\n" }, { "path": "3Sum/3Sum.cpp", "content": "class Solution {\npublic:\n vector > threeSum(vector &num) {\n vector> result;\n if (num.empty()) {\n return result;\n }\n sort(num.begin(), num.end());\n for (int start = 0; start < num.size(); start++) {\n int i = start + 1;\n int j = num.size() - 1;\n int target = -num[start];\n while (i < j) {\n if (num[i] + num[j] == target) {\n vector triple;\n triple.push_back(num[start]);\n triple.push_back(num[i]);\n triple.push_back(num[j]);\n result.push_back(triple);\n while (i + 1 < num.size() && num[i] == num[i+1]) {\n i++;\n }\n while (j - 1 >= 0 && num[j] == num[j-1]) {\n j--;\n }\n i++;\n j--;\n } else if (num[i] + num[j] < target) {\n i++;\n } else {\n j--;\n }\n }\n while (start + 1 < num.size() && num[start] == num[start+1]) {\n start++;\n }\n }\n return result;\n }\n};\n" }, { "path": "3SumClosest/3SumClosest.cpp", "content": "class Solution {\npublic:\n int threeSumClosest(vector &num, int target) {\n sort(num.begin(), num.end());\n int delta = INT_MAX;\n int closest = 0;\n for (int i = 0; i < num.size(); i++) {\n int start = i + 1;\n int limit = num.size() - 1;\n while (start < limit) {\n int sum = num[i] + num[start] + num[limit];\n if (abs(sum - target) < delta) {\n delta = abs(sum - target);\n closest = sum;\n }\n if (sum == target) {\n return target;\n } else if (sum < target) {\n start++;\n } else {\n limit--;\n }\n }\n }\n return closest;\n }\n};\n" }, { "path": "4Sum/4Sum.cpp", "content": "\nstruct twoSum {\n int lf, rt, val;\n twoSum(int _lf, int _rt, int _val)\n : lf(_lf), rt(_rt), val(_val) { }\n friend bool operator < (const twoSum& lhs, const twoSum& rhs) {\n return lhs.val < rhs.val;\n }\n};\n\nclass Solution {\npublic:\n vector> fourSum(vector& num, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n vector> result;\n vector twosums;\n for (int i = 0; i < num.size(); i++) {\n for (int j = i + 1; j < num.size(); j++)\n twosums.push_back(twoSum(i, j, num[i]+num[j]));\n }\n sort(twosums.begin(), twosums.end());\n \n int n = twosums.size();\n for (int i = 0; i < n; i++) {\n int value = target - twosums[i].val;\n int lf = find_lower_bound(twosums, i + 1, n - 1, value);\n int rt = find_upper_bound(twosums, i + 1, n - 1, value);\n for (int j = lf; j <= rt; j++) {\n if (twosums[i].lf == twosums[j].lf) continue;\n if (twosums[i].rt == twosums[j].lf) continue;\n if (twosums[i].lf == twosums[j].rt) continue;\n if (twosums[i].rt == twosums[j].rt) continue;\n vector four;\n four.push_back(num[twosums[i].lf]);\n four.push_back(num[twosums[i].rt]);\n four.push_back(num[twosums[j].lf]);\n four.push_back(num[twosums[j].rt]);\n sort(four.begin(), four.end());\n if (find(result.begin(), result.end(), four) == result.end())\n result.push_back(four);\n }\n }\n return move(result);\n }\n int find_lower_bound(vector& twosums, int l, int r, int val) {\n while (l <= r) {\n int m = (l + r) / 2;\n if (twosums[m].val >= val)\n r = m - 1;\n else\n l = m + 1;\n }\n return r + 1;\n }\n int find_upper_bound(vector& twosums, int l, int r, int val) {\n while (l <= r) {\n int m = (l + r) / 2;\n if (twosums[m].val <= val)\n l = m + 1;\n else\n r = m - 1;\n }\n return l - 1;\n }\n};" }, { "path": "AddBinary/AddBinary.cpp", "content": "class Solution {\npublic:\n string addBinary(string a, string b) {\n string c;\n reverse(a.begin(), a.end());\n reverse(b.begin(), b.end());\n int carry = 0;\n int i = 0;\n while (i < a.size() && i < b.size()) {\n carry += a[i] - '0' + b[i] - '0';\n c += carry % 2 + '0';\n carry /= 2;\n i++;\n }\n while (i < a.size()) {\n carry += a[i] - '0';\n c += carry % 2 + '0';\n carry /= 2;\n i++;\n }\n while (i < b.size()) {\n carry += b[i] - '0';\n c += carry % 2 + '0';\n carry /= 2;\n i++;\n }\n while (carry) {\n c += carry % 2 + '0';\n carry /= 2;\n }\n reverse(c.begin(), c.end());\n return c;\n }\n};\n" }, { "path": "AddTwoNumbers/AddTwoNumbers.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int carry = 0;\n ListNode *list = new ListNode(0);\n ListNode *head = list;\n ListNode *prev = list;\n while (l1 && l2) {\n carry += l1->val + l2->val;\n \n list = new ListNode(0);\n list->val = carry % 10;\n carry /= 10;\n\n l1 = l1->next;\n l2 = l2->next;\n prev->next = list;\n prev = prev->next;\n }\n while (l1) {\n carry += l1->val;\n \n list = new ListNode(0);\n list->val = carry % 10;\n carry /= 10;\n\n l1 = l1->next;\n prev->next = list;\n prev = prev->next;\n }\n while (l2) {\n carry += l2->val;\n \n list = new ListNode(0);\n list->val = carry % 10;\n carry /= 10;\n\n l2 = l2->next;\n prev->next = list;\n prev = prev->next;\n }\n if (carry) {\n list = new ListNode(0);\n list->val = carry;\n prev->next = list;\n prev = prev->next;\n }\n return head->next;\n }\n};\n" }, { "path": "Anagrams/Anagrams.cpp", "content": "class Solution {\npublic:\n vector anagrams(vector &strs) {\n vector result;\n map exists;\n for (int i = 0; i < strs.size(); i++) {\n string u = strs[i];\n sort(u.begin(), u.end());\n if (exists.find(u) == exists.end()) {\n exists[u] = i;\n } else {\n if (exists[u] >= 0) {\n result.push_back(strs[exists[u]]);\n exists[u] = -1;\n }\n result.push_back(strs[i]);\n }\n }\n return result;\n }\n};\n" }, { "path": "BalancedBinaryTree/BalancedBinaryTree.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool isBalanced(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n bool flag = true;\n dfs(root, flag);\n return flag;\n }\n int dfs(TreeNode* node, bool& flag) {\n if (node == NULL)\n return 0;\n int lf = 1 + dfs(node->left, flag);\n int rt = 1 + dfs(node->right, flag);\n \n if (abs(rt - lf) > 1)\n flag = false;\n return max(lf, rt);\n }\n};" }, { "path": "BestTimetoBuyandSellStock/BestTimetoBuyandSellStock.cpp", "content": "class Solution {\npublic:\n int maxProfit(vector &prices) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int minval = 0x3FFFFFFF;\n int maxprofit = 0;\n for (size_t i = 0; i < prices.size(); i++) {\n minval = min(minval, prices[i]);\n maxprofit = max(maxprofit, prices[i] - minval);\n }\n return maxprofit;\n }\n};\n" }, { "path": "BestTimetoBuyandSellStockII/BestTimetoBuyandSellStockII.cpp", "content": "class Solution {\npublic:\n int maxProfit(vector& prices) {\n \n if (prices.empty()) return 0;\n\n int maxprofit = 0;\n int minvalue = INFS;\n for (size_t i = 0; i < prices.size(); i++) {\n minvalue = min(prices[i], minvalue);\n int profit = prices[i] - minvalue;\n if (profit > 0) {\n maxprofit += profit;\n minvalue = prices[i];\n }\n }\n return maxprofit;\n }\n //\n // firstly I thought this is a dynamic programming problem\n // but unfortunately, TLE in O(n^2)\n // It's a greed problem in O(n)\n //\n int maxProfit2(vector &prices) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (prices.empty()) return 0;\n\n vector dp(prices.size());\n dp[0] = 0;\n for (size_t i = 1; i < prices.size(); i++) {\n int maxvalue = prices[i];\n int maxprofit = 0;\n for (int j = i-1; j >= 0; j--) {\n maxvalue = max(maxvalue, prices[j]);\n maxprofit = max(maxprofit, maxvalue - prices[j]);\n dp[i] = max(dp[i], dp[j] + maxprofit);\n }\n }\n return dp[prices.size()-1];\n }\nprivate:\n static const int INFS = 0x3FFFFFFF;\n};\n" }, { "path": "BestTimetoBuyandSellStockIII/BestTimetoBuyandSellStockIII.cpp", "content": "class Solution {\npublic:\n int maxProfit(vector &prices) {\n if (prices.size() < 2) {\n return 0;\n }\n int n = prices.size();\n vector dp1(n, 0);\n vector dp2(n, 0);\n int minval = prices[0];\n for (int i = 1; i < n; i++) {\n minval = min(minval, prices[i]);\n dp1[i] = max(dp1[i-1], prices[i] - minval);\n }\n int maxval = prices[n-1];\n for (int i = n - 2; i >= 0; i--) {\n maxval = max(maxval, prices[i]);\n dp2[i] = max(dp2[i+1], maxval - prices[i]);\n }\n int result = 0;\n for (int i = 0; i < n; i++) {\n result = max(result, dp1[i] + dp2[i]);\n }\n return result;\n }\n};\n" }, { "path": "BinaryTreeInorderTraversal/BinaryTreeInorderTraversal.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector inorderTraversal(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector inorder;\n stack tree_stack;\n TreeNode *node = root;\n \n while (node || !tree_stack.empty()) {\n while (node) {\n tree_stack.push(node);\n node = node->left;\n }\n if (!tree_stack.empty()) {\n node = tree_stack.top();\n tree_stack.pop();\n inorder.push_back(node->val);\n node = node->right;\n }\n }\n return inorder;\n }\n};\n\n// solution 2, O(1) space\nclass Solution {\npublic:\n vector inorderTraversal(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector inorder;\n TreeNode *current = root;\n \n while (current != NULL) {\n if (current->left == NULL) {\n inorder.push_back(current->val);\n current = current->right;\n }\n else {\n TreeNode *prev = current->left;\n while (prev->right && prev->right != current)\n prev = prev->right;\n if (prev->right == NULL) {\n prev->right = current;\n current = current->left;\n }\n else {\n inorder.push_back(current->val);\n prev->right = NULL;\n current = current->right;\n }\n }\n }\n return inorder;\n }\n};" }, { "path": "BinaryTreeLevelOrderTraversal/BinaryTreeLevelOrderTraversal.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector > levelOrder(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> result;\n if (root == NULL) return result;\n \n queue nodeQueue;\n vector value;\n nodeQueue.push(root);\n int nodeNow = 1;\n int nodeNext = 0;\n \n while (!nodeQueue.empty()) {\n TreeNode *node = nodeQueue.front();\n nodeQueue.pop();\n nodeNow -= 1;\n value.push_back(node->val);\n if (node->left) {\n nodeQueue.push(node->left);\n nodeNext += 1;\n }\n if (node->right) {\n nodeQueue.push(node->right);\n nodeNext += 1;\n }\n if (nodeNow == 0) {\n result.push_back(value);\n value.clear();\n nodeNow = nodeNext;\n nodeNext = 0;\n }\n }\n return move(result);\n }\n};" }, { "path": "BinaryTreeLevelOrderTraversalII/BinaryTreeLevelOrderTraversalII.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector > levelOrderBottom(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> result;\n if (root == NULL) return result;\n \n queue nodeQueue;\n vector value;\n nodeQueue.push(root);\n int nodeNow = 1;\n int nodeNext = 0;\n \n while (!nodeQueue.empty()) {\n TreeNode *node = nodeQueue.front();\n nodeQueue.pop();\n nodeNow -= 1;\n value.push_back(node->val);\n if (node->left) {\n nodeQueue.push(node->left);\n nodeNext += 1;\n }\n if (node->right) {\n nodeQueue.push(node->right);\n nodeNext += 1;\n }\n if (nodeNow == 0) {\n result.push_back(value);\n value.clear();\n nodeNow = nodeNext;\n nodeNext = 0;\n }\n }\n reverse(result.begin(), result.end());\n return move(result);\n }\n};" }, { "path": "BinaryTreeMaximumPathSum/BinaryTreeMaximumPathSum.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n int maxPathSum(TreeNode *root) {\n if (root == NULL) {\n return 0;\n }\n int maxsum = INT_MIN;\n dfs(root, &maxsum);\n return maxsum;\n }\n \n int dfs(TreeNode* node, int* maxsum) {\n if (node == NULL) {\n return 0;\n }\n int left = dfs(node->left, maxsum);\n int right = dfs(node->right, maxsum);\n int val = node->val;\n if (max(left, right) > 0) {\n val += max(left, right);\n }\n int sum = node->val;\n if (left > 0) {\n sum += left;\n }\n if (right > 0) {\n sum += right;\n }\n *maxsum = max(*maxsum, sum);\n return val;\n }\n};\n" }, { "path": "BinaryTreePostorderTraversal/BinaryTreePostorderTraversal.cc", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n void print(vector& result, TreeNode* from, TreeNode* to) {\n vector temp;\n while (true) {\n temp.push_back(from->val);\n if (from == to) {\n break;\n }\n from = from->right;\n }\n for (int i = temp.size() - 1; i >= 0; i--) {\n result.push_back(temp[i]);\n }\n }\n \n vector postorderTraversal(TreeNode *root) {\n vector result;\n TreeNode prev(0);\n prev.left = root;\n TreeNode* curr = &prev;\n while (curr != NULL) {\n if (curr->left == NULL) {\n curr = curr->right;\n } else {\n TreeNode* next = curr->left;\n while (next->right && next->right != curr) {\n next = next->right;\n }\n if (next->right == NULL) {\n next->right = curr;\n curr = curr->left;\n } else {\n print(result, curr->left, next);\n next->right = NULL;\n curr = curr->right;\n }\n }\n }\n return result;\n }\n};\n" }, { "path": "BinaryTreePreorderTraversal/BinaryTreePreorderTraversal.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector preorderTraversal(TreeNode *root) {\n vector result;\n TreeNode* node = root;\n while (node) {\n if (node->left == NULL) {\n result.push_back(node->val);\n node = node->right;\n } else {\n TreeNode* next = node->left;\n while (next->right && next->right != node) {\n next = next->right;\n }\n if (next->right == NULL) {\n next->right = node;\n result.push_back(node->val);\n node = node->left;\n } else {\n next->right = NULL;\n node = node->right;\n }\n }\n }\n return result;\n }\n};\n" }, { "path": "BinaryTreeZigzagLevelOrderTraversal/BinaryTreeZigzagLevelOrderTraversal.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector> zigzagLevelOrder(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> result;\n if (root == NULL) return result;\n \n stack stackNow;\n stack stackNext;\n vector value;\n bool left2right = true;\n stackNow.push(root);\n \n while (!stackNow.empty()) {\n TreeNode *node = stackNow.top();\n stackNow.pop();\n value.push_back(node->val);\n if (left2right) {\n if (node->left)\n stackNext.push(node->left);\n if (node->right)\n stackNext.push(node->right);\n }\n else {\n if (node->right)\n stackNext.push(node->right);\n if (node->left)\n stackNext.push(node->left);\n }\n if (stackNow.empty()) {\n result.push_back(value);\n value.clear();\n left2right = !left2right;\n swap(stackNow, stackNext);\n }\n }\n return move(result);\n }\n};" }, { "path": "ClimbingStairs/ClimbingStairs.cpp", "content": "\n\nclass Matrix {\npublic:\n int x00, x01;\n int x10, x11;\n Matrix() {}\n Matrix(int _x00, int _x01, int _x10, int _x11)\n : x00(_x00), x01(_x01), x10(_x10), x11(_x11) {}\n Matrix operator * (const Matrix& o) {\n Matrix m;\n m.x00 = x00 * o.x00 + x01 * o.x10;\n m.x01 = x00 * o.x01 + x01 * o.x11;\n m.x10 = x10 * o.x00 + x11 * o.x10;\n m.x11 = x10 * o.x01 + x11 * o.x11;\n return m;\n }\n};\n\nclass Solution {\npublic:\n int climbStairs(int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (n <= 1) return 1;\n Matrix m(1, 1, 1, 0);\n Matrix e(1, 0, 1, 0);\n while (n) {\n if (n & 1)\n e = e * m;\n m = m * m;\n n /= 2;\n }\n return e.x10;\n }\n};" }, { "path": "CloneGraph/CloneGraph.cc", "content": "/**\n * Definition for undirected graph.\n * struct UndirectedGraphNode {\n * int label;\n * vector neighbors;\n * UndirectedGraphNode(int x) : label(x) {};\n * };\n */\nclass Solution {\npublic:\n UndirectedGraphNode* clone(UndirectedGraphNode* node, map& graph) {\n if (node == NULL) {\n return NULL;\n } \n if (graph.find(node) != graph.end()) {\n return graph[node];\n }\n UndirectedGraphNode* newnode = new UndirectedGraphNode(node->label);\n graph[node] = newnode;\n for (int i = 0; i < node->neighbors.size(); i++) {\n UndirectedGraphNode* next = clone(node->neighbors[i], graph);\n newnode->neighbors.push_back(next);\n }\n return newnode;\n }\n \n UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {\n map graph;\n return clone(node, graph);\n }\n};\n" }, { "path": "CombinationSum/CombinationSum.cpp", "content": "class Solution {\npublic:\n vector > combinationSum(vector &candidates, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n combination_set.clear();\n sort(candidates.begin(), candidates.end());\n vector nums;\n DFS(nums, target, candidates, 0);\n return move(combination_set);\n }\n \n void DFS(vector& nums, int target, vector& candidates, int position) {\n if (target < 0) return;\n \n if (target == 0) {\n combination_set.push_back(nums);\n return;\n }\n \n if (position >= candidates.size())\n return;\n \n DFS(nums, target, candidates, position + 1);\n \n int value = candidates[position];\n \n for (int i = 1; i * value <= target; i++) {\n for (int j = 0; j < i; j++)\n nums.push_back(value);\n \n DFS(nums, target - i * value, candidates, position + 1);\n \n for (int j = 0; j < i; j++)\n nums.pop_back();\n }\n }\n\nprivate:\n vector> combination_set;\n};" }, { "path": "CombinationSumII/CombinationSumII.cpp", "content": "class Solution {\npublic:\n vector> combinationSum2(vector& candidates, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n combination_set.clear();\n sort(candidates.begin(), candidates.end());\n vector nums;\n DFS(nums, target, candidates, 0);\n return move(combination_set);\n }\n \n void DFS(vector& nums, int target, vector& candidates, int position) {\n if (target < 0) return;\n \n if (target == 0) {\n if (find(combination_set.begin(), combination_set.end(), nums) == combination_set.end())\n combination_set.push_back(nums);\n return;\n }\n \n if (position >= candidates.size())\n return;\n \n DFS(nums, target, candidates, position + 1);\n \n int value = candidates[position];\n if (value <= target) {\n nums.push_back(value);\n DFS(nums, target - value, candidates, position + 1);\n nums.pop_back();\n } \n }\nprivate:\n vector> combination_set;\n};" }, { "path": "Combinations/Combinations.cpp", "content": "class Solution {\npublic:\n vector > combine(int n, int k) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> result;\n vector comb;\n DFS(comb, 0, 0, k, n, result);\n return move(result);\n }\n \n void DFS(vector& comb, int step, int p, int k, int n, vector>& result) {\n if (step == k) {\n result.push_back(comb);\n return;\n }\n if (n - p < k - step) \n return;\n \n comb.push_back(p + 1);\n DFS(comb, step + 1, p + 1, k, n, result);\n comb.pop_back();\n \n DFS(comb, step, p + 1, k, n, result);\n }\n};" }, { "path": "ConstructBinaryTreefromInorderandPostorderTraversal/ConstructBinaryTreefromInorderandPostorderTraversal.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode *buildTree(vector &inorder, vector &postorder) {\n if (inorder.empty()) {\n return NULL;\n }\n return dfs(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);\n }\n TreeNode* dfs(vector& inorder, int l1, int r1, vector& postorder, int l2, int r2) {\n if (l1 > r1) {\n return NULL;\n }\n if (l1 == r1) {\n return new TreeNode(inorder[l1]);\n }\n TreeNode* root = new TreeNode(postorder[r2]);\n for (int i = l1; i <= r1; i++) {\n if (inorder[i] == postorder[r2]) {\n root->left = dfs(inorder, l1, i - 1, postorder, l2, l2 + i - l1 - 1);\n root->right = dfs(inorder, i + 1, r1, postorder, l2 + i - l1, r2 - 1);\n return root;\n }\n }\n return NULL;\n }\n};\n" }, { "path": "ConstructBinaryTreefromPreorderandInorderTraversal/ConstructBinaryTreefromPreorderandInorderTraversal.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode *buildTree(vector &preorder, vector &inorder) {\n if (preorder.size() == 0) {\n return NULL;\n }\n return dfs(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);\n }\n \n TreeNode* dfs(vector& preorder, int l1, int r1, vector& inorder, int l2, int r2) {\n if (l1 > r1) {\n return NULL;\n }\n if (l1 == r1) {\n return new TreeNode(preorder[l1]);\n }\n TreeNode* root = new TreeNode(preorder[l1]);\n for (int i = l2; i <= r2; i++) {\n if (inorder[i] == preorder[l1]) {\n root->left = dfs(preorder, l1 + 1, l1 + i - l2, inorder, l2, i - 1);\n root->right = dfs(preorder, l1 + i - l2 + 1, r1, inorder, i + 1, r2);\n return root;\n }\n }\n return NULL;\n }\n};\n" }, { "path": "ContainerWithMostWater/ContainerWithMostWater.cpp", "content": "class Solution {\npublic:\n int maxArea(vector& height) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (height.size() < 2)\n return 0;\n int left = 0;\n int right = height.size() - 1;\n int maxarea = 0;\n while (left < right) {\n maxarea = max(maxarea, min(height[left], height[right]) * (right - left));\n if (height[left] < height[right]) \n left += 1;\n else\n right -= 1;\n }\n return maxarea;\n }\n};" }, { "path": "ConvertSortedArraytoBinarySearchTree/ConvertSortedArraytoBinarySearchTree.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode *sortedArrayToBST(vector &num) {\n return dfs(num, 0, num.size() - 1);\n }\n TreeNode* dfs(vector& num, int start, int limit) {\n if (start > limit) {\n return NULL;\n }\n if (start == limit) {\n return new TreeNode(num[start]);\n }\n int middle = (start + limit) / 2;\n TreeNode* root = new TreeNode(num[middle]);\n root->left = dfs(num, start, middle - 1);\n root->right = dfs(num, middle + 1, limit);\n return root;\n }\n};\n" }, { "path": "ConvertSortedListtoBinarySearchTree/ConvertSortedListtoBinarySearchTree.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\n/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n TreeNode *sortedListToBST(ListNode *head) {\n if (head == NULL) {\n return NULL;\n }\n if (head->next == NULL) {\n return new TreeNode(head->val);\n }\n ListNode prevhead(0);\n prevhead.next = head;\n ListNode* prev = &prevhead;\n ListNode* one = head;\n ListNode* two = head;\n while (two && two->next) {\n prev = prev->next;\n one = one->next;\n two = two->next->next;\n }\n TreeNode* root = new TreeNode(one->val);\n ListNode* temp = one->next;\n prev->next = NULL;\n one->next = NULL;\n root->left = sortedListToBST(head);\n root->right = sortedListToBST(temp);\n return root;\n }\n};\n\n\n\n\n\n\n\n\n\n" }, { "path": "CountandSay/CountandSay.cpp", "content": "class Solution {\npublic:\n string countAndSay(int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n string begin = \"1\";\n for (int i = 0; i < n - 1; i++) {\n string next;\n int start = 0;\n while (start < begin.size()) {\n int end = start;\n int count = 0;\n while (end < begin.size() && begin[start] == begin[end]) {\n end += 1;\n count += 1;\n }\n next += char('0' + count);\n next += begin[start];\n start = end;\n }\n begin = next;\n }\n return begin;\n }\n};" }, { "path": "DecodeWays/DecodeWays.cpp", "content": "class Solution {\npublic:\n int numDecodings(string s) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (s.empty()) return 0;\n \n vector dp(s.size() + 1, 0);\n dp[0] = 1;\n for (int i = 1; i <= s.size(); i++) {\n if (s[i-1] != '0')\n dp[i] = dp[i-1];\n if (i > 1 && s[i-2] != '0') {\n int x = s[i-2] - '0';\n x = 10 * x + s[i-1] - '0';\n if (0 < x && x <= 26) \n dp[i] += dp[i-2];\n }\n }\n return dp[s.size()];\n }\n};" }, { "path": "DistinctSubsequences/DistinctSubsequences.cpp", "content": "class Solution {\npublic:\n int numDistinct(string S, string T) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int M = S.size();\n int N = T.size();\n \n if (M == 0 && N == 0)\n return 1;\n else if (M < N)\n return 0;\n \n int F[N+1];\n memset(F, 0, sizeof(int)*(N+1));\n F[0] = 1;\n for (int i = 1; i <= M; i++) {\n for (int j = N; j >= 1; j--) {\n if (S[i-1] == T[j-1])\n F[j] = F[j-1] + F[j];\n }\n }\n return F[N];\n }\n};" }, { "path": "DivideTwoIntegers/DivideTwoIntegers.cpp", "content": "class Solution {\npublic:\n int divide(int dividend, int divisor) {\n long long int divid = dividend;\n long long int divis = divisor;\n bool neg = false;\n if (divid < 0) {\n neg = neg ? false : true;\n divid = -divid;\n } \n if (divis < 0) {\n neg = neg ? false : true;\n divis = -divis;\n }\n long long int result = 0;\n while (divid >= divis) {\n long long int x = divis;\n int shift = 0;\n while ((x << 1) <= divid) {\n x <<= 1;\n shift += 1;\n }\n result += 1 << shift;\n divid -= x;\n }\n if (neg) {\n result = -result;\n }\n return result;\n }\n};\n" }, { "path": "EditDistance/EditDistance.cpp", "content": "class Solution {\npublic:\n int minDistance(string word1, string word2) {\n vector> dp(word1.size() + 1, vector(word2.size() + 1, 0));\n for (int i = 1; i <= word1.size(); i++) {\n dp[i][0] = i;\n }\n for (int j = 1; j <= word2.size(); j++) {\n dp[0][j] = j;\n }\n for (int i = 1; i <= word1.size(); i++) {\n for (int j = 1; j <= word2.size(); j++) {\n if (word1[i-1] == word2[j-1]) {\n dp[i][j] = dp[i-1][j-1];\n } else {\n dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1;\n dp[i][j] = min(dp[i][j], dp[i-1][j-1] + 1);\n }\n }\n }\n return dp[word1.size()][word2.size()];\n }\n};\n" }, { "path": "EvaluateReversePolishNotation/EvaluateReversePolishNotation.cpp", "content": "class Solution {\npublic:\n int evalRPN(vector &tokens) {\n stack nums;\n stack ops;\n \n for (int i = 0; i < tokens.size(); i++) {\n if (tokens[i][0] >= '0' && tokens[i][0] <= '9') {\n int value = atoi(tokens[i].c_str());\n nums.push(value);\n } else if (tokens[i].size() >= 2) {\n int value = atoi(tokens[i].c_str());\n nums.push(value);\n } else {\n int b = nums.top();\n nums.pop();\n int a = nums.top();\n nums.pop();\n int c;\n switch (tokens[i][0]) {\n case '+':\n c = a + b;\n break;\n case '-':\n c = a - b;\n break;\n case '*':\n c = a * b;\n break;\n case '/':\n c = a / b;\n break;\n }\n nums.push(c);\n }\n }\n return nums.top();\n }\n};\n" }, { "path": "FirstMissingPositive/FirstMissingPositive.cpp", "content": "class Solution {\npublic:\n int firstMissingPositive(int A[], int n) {\n int i = 0;\n while (i < n) {\n if (0 < A[i] && A[i] <= n && A[i] != A[A[i]-1]) {\n swap(A[i], A[A[i]-1]);\n } else {\n i++;\n }\n }\n for (int i = 0; i < n; i++) {\n if (A[i] != i + 1) {\n return i + 1;\n }\n }\n return n + 1;\n }\n};\n" }, { "path": "FlattenBinaryTreetoLinkedList/FlattenBinaryTreetoLinkedList.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n void flatten(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (root == NULL) return;\n \n stack tree_stack;\n TreeNode *flatten_node = NULL;\n tree_stack.push(root);\n \n while (!tree_stack.empty()) {\n TreeNode *node = tree_stack.top();\n tree_stack.pop();\n if (node->right) {\n tree_stack.push(node->right);\n node->right = NULL;\n }\n if (node->left) {\n tree_stack.push(node->left);\n node->left = NULL;\n }\n if (flatten_node == NULL) {\n flatten_node = node;\n } else {\n flatten_node->right = node;\n flatten_node = flatten_node->right;\n }\n }\n }\n};\n\n// recursion\nclass Solution {\npublic:\n void flatten(TreeNode *root) {\n dfs(root);\n }\n \n pair dfs(TreeNode* root) {\n if (root == NULL) {\n return make_pair((TreeNode*)NULL, (TreeNode*)NULL);\n }\n pair left = dfs(root->left);\n pair right = dfs(root->right);\n root->left = NULL;\n root->right = NULL;\n if (left.first && right.first) {\n root->right = left.first;\n left.second->right = right.first;\n return make_pair(root, right.second);\n } else if (left.first) {\n root->right = left.first;\n return make_pair(root, left.second);\n } else if (right.first) {\n root->right = right.first;\n return make_pair(root, right.second);\n }\n return make_pair(root, root);\n }\n};\n" }, { "path": "GenerateParentheses/GenerateParentheses.cpp", "content": "class Solution {\npublic:\n vector generateParenthesis(int n) {\n vector result;\n string s;\n if (n == 0) {\n return result;\n }\n dfs(result, s, n, n);\n return result;\n }\n void dfs(vector& result, string& s, int left, int right) {\n if (left > right) {\n return;\n }\n if (left == 0 && right == 0) {\n result.push_back(s);\n return;\n }\n if (left >= 1) {\n s.push_back('(');\n dfs(result, s, left - 1, right);\n s.pop_back();\n }\n if (right >= 1) {\n s.push_back(')');\n dfs(result, s, left, right - 1);\n s.pop_back();\n }\n }\n};\n" }, { "path": "GrayCode/GrayCode.cpp", "content": "class Solution {\npublic:\n vector grayCode(int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector gray_code;\n for (int i = 0; i < (1 << n); i++)\n gray_code.push_back((i >> 1) ^ i);\n return gray_code;\n }\n};\n\n// More comprehensible solution\nclass Solution {\npublic:\n vector grayCode(int n) {\n vector result(1, 0);\n for (int i = 0; i < n; i++) {\n int curr = result.size();\n while (curr) {\n curr--;\n int x = result[curr];\n result.push_back((1 << i) + x);\n }\n }\n return result;\n }\n};\n" }, { "path": "ImplementstrStr/ImplementstrStr.cpp", "content": "class Solution {\npublic:\n char *strStr(char *haystack, char *needle) {\n int n = strlen(haystack);\n int m = strlen(needle);\n if (m == 0) {\n return haystack;\n }\n vector next(m, -1);\n for (int i = 1, j = -1; i < m; i++) {\n while (j != -1 && needle[j+1] != needle[i]) {\n j = next[j];\n }\n if (needle[j+1] == needle[i]) {\n j++;\n }\n next[i] = j;\n }\n for (int i = 0, j = -1; i < n; i++) {\n while (j != -1 && needle[j+1] != haystack[i]) {\n j = next[j];\n }\n if (needle[j+1] == haystack[i]) {\n j++;\n }\n if (j == m - 1) {\n return haystack + i - m + 1;\n }\n }\n return NULL;\n }\n};\n" }, { "path": "InsertInterval/InsertInterval.cpp", "content": "/**\n * Definition for an interval.\n * struct Interval {\n * int start;\n * int end;\n * Interval() : start(0), end(0) {}\n * Interval(int s, int e) : start(s), end(e) {}\n * };\n */\nclass Solution {\npublic:\n vector insert(vector &intervals, Interval newInterval) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector merged_interval;\n \n bool has_inserted = false;\n int new_start = newInterval.start;\n int new_end = newInterval.end;\n \n for (int i = 0; i < intervals.size(); i++) {\n if (intervals[i].start <= new_end && new_start <= intervals[i].end) {\n new_start = min(new_start, intervals[i].start);\n new_end = max(new_end, intervals[i].end);\n }\n else {\n if (!has_inserted && new_end < intervals[i].start) {\n has_inserted = true;\n merged_interval.push_back(Interval(new_start, new_end));\n }\n merged_interval.push_back(intervals[i]);\n }\n }\n if (!has_inserted)\n merged_interval.push_back(Interval(new_start, new_end));\n return merged_interval;\n }\n};" }, { "path": "IntegertoRoman/IntegertoRoman.cpp", "content": "class Solution {\npublic:\n string intToRoman(int num) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function \n char symbol[] = {'I', 'V', 'X', 'L','C', 'D', 'M'};\n string result;\n int base = 1000;\n int d = 6;\n while (num) {\n int digit = num / base;\n appendRoman(digit, result, symbol + d);\n d -= 2;\n num %= base;\n base /= 10;\n }\n return result;\n }\n \n void appendRoman(int n, string& s, char symbol[]) {\n assert(n <= 9);\n \n if (n == 0) return;\n if (n <= 3) {\n s.append(n, symbol[0]);\n }\n else if (n == 4) {\n s.append(1, symbol[0]);\n s.append(1, symbol[1]);\n }\n else if (n <= 8) {\n s.append(1, symbol[1]);\n s.append(n - 5, symbol[0]);\n }\n else if (n == 9) {\n s.append(1, symbol[0]);\n s.append(1, symbol[2]);\n }\n }\n};" }, { "path": "InterleavingString/InterleavingString.cpp", "content": "class Solution {\npublic:\n bool isInterleave(string s1, string s2, string s3) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function \n \n int M = s1.size();\n int N = s2.size();\n \n if (M + N != s3.size()) return false;\n \n vector> dp(2, vector(N + 1, false));\n dp[0][0] = true;\n for (int j = 1; j <= N; j++) {\n if (s2[j-1] == s3[j-1])\n dp[0][j] = true;\n else\n break;\n }\n int T1 = 1, T2 = 0;\n for (int i = 1; i <= M; i++) {\n T1 ^= 1, T2 ^= 1;\n dp[T2][0] = dp[T1][0] && s1[i-1] == s3[i-1];\n for (int j = 1; j <= N; j++) {\n if (s3[i+j-1] == s1[i-1] && s3[i+j-1] == s2[j-1])\n dp[T2][j] = dp[T1][j] | dp[T2][j-1];\n else if (s3[i+j-1] == s1[i-1] && s3[i+j-1] != s2[j-1])\n dp[T2][j] = dp[T1][j];\n else if (s3[i+j-1] != s1[i-1] && s3[i+j-1] == s2[j-1])\n dp[T2][j] = dp[T2][j-1];\n else \n dp[T2][j] = false;\n }\n }\n return dp[T2][N];\n }\n};" }, { "path": "JumpGame/JumpGame.cpp", "content": "class Solution {\npublic:\n bool canJump(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int now = 0;\n int next = 0;\n while (now <= next) {\n next = max(next, now + A[now]);\n if (next >= n-1)\n return true;\n now += 1;\n }\n // for dynamic programming, we have below:\n // F[i] = max(F[i-1], A[i-1]) - 1;\n // if (F[i] < 0) return false;\n return false;\n }\n};" }, { "path": "JumpGameII/JumpGameII.cpp", "content": "class Solution {\npublic:\n int jump(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int begin = 0, end = 0;\n int min_step = 0;\n int max_next = 0;\n \n while (end < n - 1) {\n min_step += 1;\n for (int i = begin; i <= end; i++)\n max_next = max(max_next, i + A[i]);\n if (max_next <= end) \n return -1;\n begin = end + 1;\n end = max_next;\n }\n return min_step;\n }\n};" }, { "path": "LRUCache/LRUCache.cc", "content": "class LRUCache{\npublic:\n LRUCache(int capacity) {\n cap_ = capacity;\n dummy_.prev = &dummy_;\n dummy_.next = &dummy_;\n }\n \n int get(int key) {\n if (cache_.find(key) == cache_.end()) {\n return -1;\n }\n entry* e = cache_[key];\n e->prev = &dummy_;\n e->next = dummy_.next;\n dummy_.next->prev = e;\n dummy_.next = e;\n \n return e->val;\n }\n \n void set(int key, int value) {\n while (cache_.size() >= cap_) {\n entry* e = dummy_.prev;\n e->prev->next = &dummy_;\n dummy_.prev = e->prev;\n \n cache_.erase(e->key);\n delete(e);\n }\n \n entry* e;\n if (cache_.find(key) == cache_.end()) {\n e = new(entry);\n cache_[key] = e;\n } else {\n e = cache_[key];\n e->prev->next = e->next;\n e->next->prev = e->prev;\n }\n e->prev = &dummy_;\n e->next = dummy_.next;\n dummy_.next->prev = e;\n dummy_.next = e;\n \n e->val = value;\n }\n \nprivate:\n struct entry {\n int key;\n int val;\n entry* prev;\n entry* next;\n };\n \n int cap_;\n map cache_;\n struct entry dummy_;\n};\n" }, { "path": "LargestRectangleinHistogram/LargestRectangleinHistogram.cpp", "content": "class Solution {\npublic:\n int largestRectangleArea(vector& height) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int n = height.size();\n int width[n];\n stack minHeight;\n \n for (int i = 0; i < n; i++) {\n while (!minHeight.empty() && height[i] <= height[minHeight.top()])\n minHeight.pop();\n int left = minHeight.empty() ? -1 : minHeight.top();\n width[i] = i - left - 1;\n minHeight.push(i);\n }\n \n while (!minHeight.empty())\n minHeight.pop();\n \n for (int i = n - 1; i >= 0; i--) {\n while (!minHeight.empty() && height[i] <= height[minHeight.top()])\n minHeight.pop();\n int right = minHeight.empty() ? n : minHeight.top();\n width[i] += right - i - 1;\n minHeight.push(i);\n }\n \n int result = 0;\n for (int i = 0; i < n; i++) \n result = max(result, height[i] * (width[i] + 1));\n return result;\n }\n};" }, { "path": "LengthofLastWord/LengthofLastWord.cpp", "content": "class Solution {\npublic:\n int lengthOfLastWord(const char *s) {\n int curr = 0;\n const char* p = s;\n while (*p != '\\0') {\n if (*p == ' ') {\n p++;\n } else {\n curr = 0;\n while (*p != '\\0' && *p != ' ') {\n p++;\n curr++;\n }\n }\n }\n return curr;\n }\n};\n" }, { "path": "LetterCombinationsofaPhoneNumber/LetterCombinationsofaPhoneNumber.cpp", "content": "class Solution {\npublic:\n vector letterCombinations(string digits) {\n map keypad;\n keypad[2] = string(\"abc\");\n keypad[3] = string(\"def\");\n keypad[4] = string(\"ghi\");\n keypad[5] = string(\"jkl\");\n keypad[6] = string(\"mno\");\n keypad[7] = string(\"pqrs\");\n keypad[8] = string(\"tuv\");\n keypad[9] = string(\"wxyz\");\n \n vector result;\n string letter;\n dfs(result, letter, digits, 0, keypad);\n return result;\n }\n void dfs(vector& result, string& letter, string& digits, int pos, map& keypad) {\n if (pos == digits.size()) {\n result.push_back(letter);\n return;\n }\n int x = digits[pos] - '0';\n string s = keypad[x];\n for (int i = 0; i < s.size(); i++) {\n letter.push_back(s[i]);\n dfs(result, letter, digits, pos + 1, keypad);\n letter.pop_back();\n }\n }\n};\n" }, { "path": "LongestCommonPrefix/LongestCommonPrefix.cpp", "content": "class Solution {\npublic:\n string longestCommonPrefix(vector &strs) {\n if (strs.empty()) {\n return string();\n }\n for (int i = 0; i < strs[0].size(); i++) {\n for (int j = 1; j < strs.size(); j++) {\n if (i == strs[j].size()) {\n return strs[j];\n } else if (i < strs[j].size() && strs[0][i] != strs[j][i]) {\n return strs[j].substr(0, i);\n }\n }\n }\n return strs[0];\n }\n};\n" }, { "path": "LongestConsecutiveSequence/LongestConsecutiveSequence.cpp", "content": "class Solution {\npublic:\n int longestConsecutive(vector &num) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n priority_queue Q;\n for (int i = 0; i < num.size(); i++) {\n Q.push(num[i]);\n }\n int ret = 1;\n int maxlen = 1;\n int temp = Q.top();\n Q.pop();\n while (!Q.empty()) {\n if (temp - 1 == Q.top()) {\n temp -= 1;\n maxlen += 1; \n } else if (temp != Q.top()) {\n temp = Q.top();\n maxlen = 1;\n }\n Q.pop();\n ret = max(maxlen, ret);\n }\n return ret;\n }\n};\n\n// O(n) solution\n\nclass Solution {\npublic:\n int longestConsecutive(vector &num) {\n unordered_map longest;\n int result = 0;\n \n for (int i = 0; i < num.size(); i++) {\n if (longest[num[i]] != 0) {\n continue;\n }\n \n int leftbound = longest[num[i]-1];\n int rightbound = longest[num[i]+1];\n int bound = leftbound + rightbound + 1;\n \n longest[num[i]] = bound;\n longest[num[i]-leftbound] = bound;\n longest[num[i]+rightbound] = bound;\n \n if (result < bound) {\n result = bound;\n }\n }\n return result;\n }\n};\n" }, { "path": "LongestPalindromicSubstring/LongestPalindromicSubstring.cpp", "content": "class Solution {\npublic:\n string longestPalindrome(string s) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int beg = 0, end = 0;\n int longest = 1;\n \n for (int i = 0; i < s.size(); i++) {\n dp[i][i] = dp[i+1][i] = true;\n }\n for (int d = 1; d < s.size(); d++) {\n for (int i = 0, j = i + d; j < s.size(); i++, j++) {\n dp[i][j] = false;\n if (s[i] == s[j]) dp[i][j] |= dp[i+1][j-1];\n if (dp[i][j] && longest < j-i+1) {\n beg = i, end = j;\n }\n }\n }\n return s.substr(beg, end - beg + 1);\n }\nprivate:\n static const int MAXN = 1010;\n bool dp[MAXN][MAXN];\n};\n" }, { "path": "LongestSubstringWithoutRepeatingCharacters/LongestSubstringWithoutRepeatingCharacters.cpp", "content": "class Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n int hash[256];\n for (int i = 0; i < 256; i++) {\n hash[i] = -1;\n }\n int maxlen = 0;\n int start = 0;\n for (int limit = 0; limit < s.size(); limit++) {\n if (hash[s[limit]] != -1) {\n start = max(start, hash[s[limit]] + 1);\n }\n maxlen = max(maxlen, limit - start + 1);\n hash[s[limit]] = limit;\n }\n return maxlen;\n }\n};\n" }, { "path": "LongestValidParentheses/LongestValidParentheses.cpp", "content": "class Solution {\npublic:\n int longestValidParentheses(string s) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int n = s.size();\n int max_valid = 0;\n int count_left = 0, valid_count = 0;\n \n for (int i = 0; i < n; i++) {\n if (s[i] == '(') {\n count_left += 1;\n valid_count += 1;\n } else {\n valid_count -= 1;\n }\n \n if (valid_count < 0) {\n valid_count = 0;\n count_left = 0;\n } else if (valid_count == 0) {\n max_valid = max(max_valid, count_left);\n }\n }\n \n valid_count = 0;\n int count_right = 0;\n for (int i = n - 1; i >= 0; i--) {\n if (s[i] == ')') {\n count_right += 1;\n valid_count += 1;\n } else {\n valid_count -= 1;\n }\n \n if (valid_count < 0) {\n valid_count = 0;\n count_right = 0;\n } else if (valid_count == 0) {\n max_valid = max(max_valid, count_right);\n }\n }\n return 2 * max_valid;\n }\n};\n" }, { "path": "MaxPointsOnALine/MaxPointsOnALine.cpp", "content": "/**\n * Definition for a point.\n * struct Point {\n * int x;\n * int y;\n * Point() : x(0), y(0) {}\n * Point(int a, int b) : x(a), y(b) {}\n * };\n */\n\nbool operator<(const Point& x, const Point& y) {\n if (x.x == y.x) {\n return x.y < y.y;\n }\n return x.x < y.x;\n}\n\nbool operator==(const Point& x, const Point& y) {\n if (x.x == y.x && x.y == y.y) {\n return true;\n }\n return false;\n}\n\nclass Solution {\npublic:\n int maxPoints(vector &points) {\n int n = points.size();\n if (n <= 2) {\n return n;\n }\n int result = 2;\n sort(points.begin(), points.end());\n for (int i = 0; i < n; i++) {\n vector> slopes;\n int count = 0;\n for (int j = i + 1; j < n; j++) {\n int x = points[i].x - points[j].x;\n int y = points[i].y - points[j].y;\n int z = gcd(x, y);\n if (z != 0) {\n x /= z, y /= z;\n }\n if (x == 0 && y == 0) {\n count++;\n } else {\n slopes.push_back(make_pair(x, y));\n }\n }\n if (slopes.empty()) {\n result = max(result, count + 1);\n continue;\n }\n sort(slopes.begin(), slopes.end());\n int curr = 2 + count;\n result = max(result, curr);\n for (int j = 1; j < slopes.size(); j++) {\n if (slopes[j] == slopes[j-1]) {\n curr++;\n } else {\n curr = 2 + count;\n }\n result = max(result, curr);\n }\n }\n return result;\n }\n \n int gcd(int a, int b) {\n while (b != 0) {\n int t = b;\n b = a % b;\n a = t;\n }\n return a;\n }\n};\n" }, { "path": "MaximalRectangle/MaximalRectangle.cpp", "content": "class Solution {\npublic:\n int maximalRectangle(vector > &matrix) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int row = matrix.size();\n if (row == 0) return 0;\n int col = matrix[0].size();\n \n int result = 0;\n int height[col];\n memset(height, 0, sizeof(int)*col);\n \n for (int i = 0; i < row; i++) {\n for (int j = 0; j < col; j++) {\n if (matrix[i][j] == '1')\n height[j] += 1;\n else \n height[j] = 0;\n }\n int rect = getLargestRectInHistogram(height, col);\n result = max(result, rect);\n }\n return result;\n }\n \n int getLargestRectInHistogram(const int height[], int n) {\n int width[n];\n stack minHeight;\n int result = 0;\n \n for (int i = 0; i < n; i++) {\n while (!minHeight.empty() && height[i] <= height[minHeight.top()])\n minHeight.pop();\n int left = minHeight.empty() ? -1 : minHeight.top();\n width[i] = i - left - 1;\n minHeight.push(i);\n }\n \n while (!minHeight.empty())\n minHeight.pop();\n \n for (int i = n-1; i >= 0; i--) {\n while (!minHeight.empty() && height[i] <= height[minHeight.top()])\n minHeight.pop();\n int right = minHeight.empty() ? n : minHeight.top();\n width[i] += right - i - 1;\n minHeight.push(i);\n }\n \n for (int i = 0; i < n; i++) {\n result = max(result, height[i] * (width[i] + 1));\n }\n return result;\n }\n};\n\n" }, { "path": "MaximumDepthofBinaryTree/MaximumDepthofBinaryTree.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n int maxDepth(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (root == NULL)\n return 0;\n int lf = 1 + maxDepth(root->left);\n int rt = 1 + maxDepth(root->right);\n return max(lf, rt);\n }\n};" }, { "path": "MaximumProductSubarray/MaximumProductSubarray.cpp", "content": "class Solution {\npublic:\n int maxProduct(int A[], int n) {\n if (n == 0) {\n return 0;\n }\n int result = A[0];\n int premax = A[0];\n int premin = A[0];\n for (int i = 1; i < n; i++) {\n int heremax = max(A[i], max(A[i] * premax, A[i] * premin));\n int heremin = min(A[i], min(A[i] * premax, A[i] * premin));\n result = max(result, heremax);\n premax = heremax;\n premin = heremin;\n }\n return result;\n }\n};\n" }, { "path": "MaximumSubarray/MaximumSubarray.cpp", "content": "class Solution {\npublic:\n int maxSubArray(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int maxsum = A[0];\n int tempsum = A[0];\n for (int i = 1; i < n; i++) {\n if (tempsum < 0) tempsum = 0;\n tempsum += A[i];\n maxsum = max(maxsum, tempsum);\n }\n return maxsum;\n }\n};\n\n// \n// solution 2 : divide and conquer\n//\nclass Solution {\npublic:\n int maxSubArray(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n return maxSubArray(A, 0, n - 1);\n }\n \n int maxSubArray(int A[], int left, int right) {\n if (left > right)\n return INT_MIN;\n \n int mid = (left + right) / 2;\n int lmax = maxSubArray(A, left, mid - 1);\n int rmax = maxSubArray(A, mid + 1, right);\n \n int sum = 0, mlmax = 0;\n for (int i = mid - 1; i >= left; i--) {\n sum += A[i];\n mlmax = max(mlmax, sum);\n }\n sum = 0;\n int mrmax = 0;\n for (int i = mid + 1; i <= right; i++) {\n sum += A[i];\n mrmax = max(mrmax, sum);\n }\n \n return max(mlmax + A[mid] + mrmax, max(lmax, rmax));\n }\n};" }, { "path": "MedianofTwoSortedArrays/MedianofTwoSortedArrays.cpp", "content": "class Solution {\npublic:\n double findMedianSortedArrays(int A[], int m, int B[], int n) {\n if ((m + n) & 1) {\n return findKth((m + n - 1) / 2, A, 0, m - 1, B, 0, n - 1);\n } else {\n int x = findKth((m + n) / 2 - 1, A, 0, m - 1, B, 0, n - 1);\n int y = findKth((m + n) / 2, A, 0, m - 1, B, 0, n - 1);\n return (x + y) / 2.0;\n }\n }\n int findKth(int k, int A[], int l1, int r1, int B[], int l2, int r2) {\n if (l1 > r1) {\n return B[l2 + k];\n }\n if (l2 > r2) {\n return A[l1 + k];\n }\n int m1 = (l1 + r1) / 2;\n int m2 = (l2 + r2) / 2;\n if (A[m1] > B[m2]) {\n if (k + 1 < m1 - l1 + 1 + m2 - l2 + 1) {\n return findKth(k, A, l1, m1 - 1, B, l2, r2);\n } else {\n return findKth(k - (m2 - l2 + 1), A, l1, r1, B, m2 + 1, r2);\n }\n } else {\n if (k + 1 < m1 - l1 + 1 + m2 - l2 + 1) {\n return findKth(k, A, l1, r1, B, l2, m2 - 1);\n } else {\n return findKth(k - (m1 - l1 + 1), A, m1 + 1, r1, B, l2, r2);\n }\n }\n }\n};\n" }, { "path": "MergeIntervals/MergeIntervals.cpp", "content": "/**\n * Definition for an interval.\n * struct Interval {\n * int start;\n * int end;\n * Interval() : start(0), end(0) {}\n * Interval(int s, int e) : start(s), end(e) {}\n * };\n */\n\ninline bool operator < (const Interval& x, const Interval& y) {\n if (x.start == y.start) {\n return x.end < y.end;\n }\n return x.start < y.start;\n}\n\nclass Solution {\npublic:\n vector merge(vector &intervals) {\n vector result;\n if (intervals.empty()) {\n return result;\n }\n sort(intervals.begin(), intervals.end());\n result.push_back(intervals[0]);\n for (int i = 1; i < intervals.size(); i++) {\n Interval& back = result.back();\n if (back.end >= intervals[i].start) {\n back.end = max(back.end, intervals[i].end);\n } else {\n result.push_back(intervals[i]);\n }\n }\n return result;\n }\n};\n" }, { "path": "MergeSortedArray/MergeSortedArray.cpp", "content": "class Solution {\npublic:\n void merge(int A[], int m, int B[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int end = m + n - 1;\n m -= 1;\n n -= 1;\n while (m >= 0 && n >= 0) {\n if (A[m] > B[n]) \n A[end--] = A[m--];\n else\n A[end--] = B[n--];\n }\n while (m >= 0) \n A[end--] = A[m--];\n while (n >= 0)\n A[end--] = B[n--];\n }\n};" }, { "path": "MergeTwoSortedLists/MergeTwoSortedLists.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n ListNode prev_head(0);\n ListNode *sorted_list = &prev_head;\n \n while (l1 && l2) {\n if (l1->val < l2->val) {\n sorted_list->next = l1;\n l1 = l1->next;\n sorted_list = sorted_list->next;\n }\n else {\n sorted_list->next = l2;\n l2 = l2->next;\n sorted_list = sorted_list->next;\n }\n }\n \n while (l1) {\n sorted_list->next = l1;\n l1 = l1->next;\n sorted_list = sorted_list->next;\n }\n while (l2) {\n sorted_list->next = l2;\n l2 = l2->next;\n sorted_list = sorted_list->next;\n }\n return prev_head.next;\n }\n};" }, { "path": "MergekSortedLists/MergekSortedLists.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *mergeKLists(vector &lists) {\n return merge(lists, 0, lists.size() - 1);\n }\n ListNode* merge(vector& lists, int left, int right) {\n if (left > right) {\n return NULL;\n }\n if (left == right) {\n return lists[left];\n }\n int mid = (left + right) / 2;\n ListNode* l1 = merge(lists, left, mid);\n ListNode* l2 = merge(lists, mid + 1, right);\n \n ListNode head(0);\n ListNode* curr = &head;\n while (l1 && l2) {\n if (l1->val < l2->val) {\n curr->next = l1;\n l1 = l1->next;\n } else {\n curr->next = l2;\n l2 = l2->next;\n }\n curr = curr->next;\n }\n while (l1) {\n curr->next = l1;\n l1 = l1->next;\n curr = curr->next;\n }\n while (l2) {\n curr->next = l2;\n l2 = l2->next;\n curr = curr->next;\n }\n return head.next;\n }\n};\n" }, { "path": "MinimumDepthofBinaryTree/MinimumDepthofBinaryTree.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n int minDepth(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (root == NULL)\n return 0;\n if (root->left == NULL && root->right == NULL)\n return 1;\n int lf = INT_MAX, rt = INT_MAX;\n if (root->left)\n lf = 1 + minDepth(root->left);\n if (root->right)\n rt = 1 + minDepth(root->right);\n return min(lf, rt);\n }\n};" }, { "path": "MinimumPathSum/MinimumPathSum.cpp", "content": "class Solution {\npublic:\n int minPathSum(vector>& grid) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int m = grid.size();\n if (m == 0) return 0;\n int n = grid[0].size();\n \n vector> dp(m, vector(n, 0));\n \n dp[0][0] = grid[0][0];\n for (int i = 1; i < m; i++)\n dp[i][0] = dp[i-1][0] + grid[i][0];\n for (int j = 1; j < n; j++)\n dp[0][j] = dp[0][j-1] + grid[0][j];\n \n for (int i = 1; i < m; i++) {\n for (int j = 1; j < n; j++)\n dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j];\n }\n return dp[m-1][n-1];\n }\n};\n\n// O(n) space\nclass Solution {\npublic:\n int minPathSum(vector > &grid) {\n if (grid.empty()) {\n return 0;\n }\n int m = grid.size();\n int n = grid[0].size();\n vector> dp(2, vector(n, 0));\n int T1 = 1;\n int T2 = 0;\n for (int i = 0; i < m; i++) {\n T1 ^= 1;\n T2 ^= 1;\n dp[T2][0] = dp[T1][0] + grid[i][0];\n for (int j = 1; j < n; j++) {\n if (i == 0) {\n dp[T2][j] = dp[T2][j-1] + grid[i][j];\n } else {\n dp[T2][j] = grid[i][j] + min(dp[T1][j], dp[T2][j-1]);\n }\n }\n }\n return dp[T2][n-1];\n }\n};\n" }, { "path": "MinimumWindowSubstring/MinimumWindowSubstring.cpp", "content": "class Solution {\npublic:\n string minWindow(string S, string T) {\n string result(\"\");\n map needed;\n map found;\n for (int i = 0; i < T.size(); i++) {\n needed[T[i]]++;\n }\n int count = 0;\n int minlen = S.size() + 1;\n for (int i = 0, j = 0; j < S.size(); j++) {\n if (needed[S[j]] == 0) {\n continue;\n }\n found[S[j]]++;\n if (found[S[j]] <= needed[S[j]]) {\n count++;\n }\n if (count == T.size()) {\n while (i <= j) {\n if (found[S[i]] == 0) {\n i++;\n } else if (found[S[i]] > needed[S[i]]) {\n found[S[i]]--;\n i++;\n } else {\n break;\n }\n }\n if (minlen > j - i + 1) {\n minlen = j - i + 1;\n result = S.substr(i, minlen);\n }\n }\n }\n return result;\n }\n};\n" }, { "path": "MultiplyStrings/MultiplyStrings.cpp", "content": "class Solution {\npublic:\n string multiply(string num1, string num2) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int len_num1 = num1.size();\n int len_num2 = num2.size();\n \n vector multiply_num(len_num1 + len_num2, 0);\n \n for (int i = len_num1 - 1; i >= 0; i--) {\n for (int j = len_num2 - 1; j >= 0; j--) {\n int a = num1[i] - '0';\n int pa = len_num1 - i - 1;\n int b = num2[j] - '0';\n int pb = len_num2 - j - 1;\n multiply_num[pa + pb] += a * b;\n }\n }\n for (int i = 0; i < multiply_num.size(); i++) {\n if (multiply_num[i] > 0) {\n multiply_num[i+1] += multiply_num[i] / 10;\n multiply_num[i] = multiply_num[i] % 10;\n }\n }\n \n while (multiply_num[multiply_num.size()-1] == 0)\n multiply_num.pop_back();\n \n string num;\n for (auto iter = multiply_num.rbegin(); iter != multiply_num.rend(); iter++)\n num += (char)(*iter + '0');\n \n if (num.empty())\n num = \"0\";\n \n return num;\n }\n};" }, { "path": "N-Queens/N-Queens.cpp", "content": "class Solution {\npublic:\n vector > solveNQueens(int n) {\n vector> result;\n if (n == 0) {\n return result;\n }\n vector sol(n, string(n, '.'));\n vector> visited(3, vector(2*n, false));\n dfs(result, sol, visited, 0);\n return result;\n }\n \n void dfs(vector>& result, vector& sol, vector>& visited, int row) {\n int n = sol.size();\n if (row == n) {\n result.push_back(sol);\n return;\n }\n for (int col = 0; col < n; col++) {\n if (visited[0][col] || visited[1][row+col] || visited[2][n-1-row+col]) {\n continue;\n }\n visited[0][col] = true;\n visited[1][row+col] = true;\n visited[2][n-1-row+col] = true;\n sol[row][col] = 'Q';\n dfs(result, sol, visited, row + 1);\n sol[row][col] = '.';\n visited[0][col] = false;\n visited[1][row+col] = false;\n visited[2][n-1-row+col] = false;\n }\n }\n};\n" }, { "path": "N-QueensII/N-QueensII.cpp", "content": "class Solution {\npublic:\n int totalNQueens(int n) {\n int result = 0;\n dfs(result, n, 0, 0, 0);\n return result;\n }\n \n void dfs(int& result, int n, int col, int l, int r) {\n int mask = (1 << n) - 1;\n if (col == mask) {\n result++;\n } else {\n int valid = mask & (~(col | l | r));\n while (valid) {\n int p = valid & (-valid);\n valid -= p;\n dfs(result, n, col + p, (l + p) << 1, (r + p) >> 1);\n }\n }\n }\n};\n" }, { "path": "NextPermutation/NextPermutation.cpp", "content": "class Solution {\npublic:\n void nextPermutation(vector &num) {\n int i = num.size() - 1;\n while (i >= 1 && num[i-1] >= num[i]) {\n i--;\n }\n if (i == 0) {\n reverse(num.begin(), num.end());\n return;\n }\n for (int j = num.size() - 1; j >= i; j--) {\n if (num[j] > num[i-1]) {\n swap(num[j], num[i-1]);\n break;\n }\n }\n reverse(num.begin() + i, num.end());\n }\n};\n" }, { "path": "PalindromeNumber/PalindromeNumber.cpp", "content": "class Solution {\npublic:\n bool isPalindrome(int x) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (x < 0) return false;\n \n int base = 1;\n while (x / base >= 10) {\n base *= 10;\n }\n while (x) {\n if (x / base != x % 10)\n return false;\n x = (x % base) / 10;\n base /= 100;\n }\n return true;\n }\n};\n" }, { "path": "PalindromePartitioning/PalindromePartitioning.cpp", "content": "class Solution {\npublic:\n vector > partition(string s) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n ans.clear();\n dynamic(s);\n vector v;\n dfs(s, 0, v);\n return ans;\n\n }\n void dfs(string& s, int p, vector& v) {\n if (p == s.size()) {\n ans.push_back(v);\n return ;\n }\n string temp;\n bool flag = false;\n for (int i = p; i < s.size(); i++) {\n temp += s[i];\n if (dp[p][i]) {\n v.push_back(temp);\n dfs(s, i+1, v);\n v.pop_back();\n }\n } \n }\n\n void dynamic(string& s) {\n memset(dp, false, sizeof(dp));\n int len = s.size();\n for (int i = 0; i < len; i++) \n dp[i][i] = true, dp[i+1][i] = true;\n for (int d = 1; d < len; d++) {\n for (int i = 0, j = i+d; j < len; i++, j++) {\n if (s[i] == s[j]) \n dp[i][j] |= dp[i+1][j-1];\n }\n }\n }\nprivate:\n vector > ans;\n bool dp[1000][1000];\n};\n" }, { "path": "PalindromePartitioningII/PalindromePartitioningII.cpp", "content": "const int MAXN = 2010;\nconst int INFS = 0x3fffffff;\n\nclass Solution {\npublic:\n\tint minCut(string s) {\n\t\t// Start typing your C/C++ solution below\n\t\t// DO NOT write int main() function\n\t\t\n\t\tint n = s.size();\n\t\tmemset(dp, false, sizeof(dp));\n\t\tfor (int i = 0; i < n; i++)\n\t\t\tdp[i+1][i] = dp[i][i] = true;\n\t\tfor (int d = 1; d < n; d++)\n\t\t\tfor (int i = 0, j = i+d; j < n; i++, j++)\n\t\t\t\tif (s[i] == s[j]) \n\t\t\t\t\tdp[i][j] |= dp[i+1][j-1];\n\t\tfor (int i = 0; i < n; i++)\n\t\t\tF[i] = INFS;\n\t\tF[0] = 0;\n\t\tfor (int i = 1; i < n; i++)\n\t\t\tfor (int j = 0; j < i; j++)\n\t\t\t\tif (dp[0][i])\n\t\t\t\t\tF[i] = 0;\n\t\t\t\telse if (dp[j+1][i])\n\t\t\t\t\tF[i] = min(F[i], F[j] + 1);\n\t\treturn F[n-1];\n\n\t}\nprivate:\n\tbool dp[MAXN][MAXN];\n\tint F[MAXN];\n};\n" }, { "path": "PartitionList/PartitionList.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *partition(ListNode *head, int x) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n ListNode less_than_head(0);\n ListNode no_less_than_head(0);\n ListNode *less_than = &less_than_head;\n ListNode *no_less_than = &no_less_than_head;\n \n ListNode *node = head;\n while (node != NULL) {\n if (node->val < x) {\n less_than->next = node;\n node = node->next;\n less_than = less_than->next;\n }\n else {\n no_less_than->next = node;\n node = node->next;\n no_less_than = no_less_than->next;\n }\n }\n no_less_than->next = NULL;\n less_than->next = no_less_than_head.next;\n return less_than_head.next;\n }\n};" }, { "path": "Pascal'sTriangle/Pascal'sTriangle.cpp", "content": "class Solution {\npublic:\n vector > generate(int numRows) {\n vector> triangle;\n if (numRows == 0) {\n return triangle;\n }\n triangle.push_back(vector(1, 1));\n for (int i = 1; i < numRows; i++) {\n vector& prev = triangle.back();\n vector row(i + 1, 0);\n row[0] = row[i] = 1;\n for (int j = 0; j < i - 1; j++) {\n row[j+1] = prev[j] + prev[j+1];\n }\n triangle.push_back(row);\n }\n return triangle;\n }\n};\n" }, { "path": "Pascal'sTriangleII/Pascal'sTriangleII.cpp", "content": "class Solution {\npublic:\n vector getRow(int rowIndex) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector row[2];\n row[0].resize(rowIndex+1);\n row[1].resize(rowIndex+1);\n row[0][0] = 1;\n \n int T1 = 1, T2 = 0;\n for (int i = 1; i <= rowIndex; i++) {\n T1 ^= 1, T2 ^= 1;\n row[T2][0] = 1;\n for (int j = 1; j < i; j++) {\n row[T2][j] = row[T1][j-1] + row[T1][j];\n }\n row[T2][i] = 1;\n }\n return move(row[T2]);\n }\n};\n" }, { "path": "PathSum/PathSum.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool hasPathSum(TreeNode *root, int sum) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (root == NULL)\n return false;\n return dfs(root, 0, sum);\n \n }\n \n bool dfs(TreeNode *node, int value, int target) {\n if (node->left == NULL && node->right == NULL) {\n if (value + node->val == target) \n return true;\n else\n return false;\n } \n bool flag = false;\n if (node->left)\n flag = dfs(node->left, node->val + value, target);\n if (flag) return true;\n if (node->right)\n return dfs(node->right, node->val + value, target);\n }\n};" }, { "path": "PathSumII/PathSumII.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector > pathSum(TreeNode *root, int sum) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n vector> result;\n vector path;\n dfs(root, 0, sum, path, result);\n return move(result);\n \n }\n void dfs(TreeNode *node, int value, int sum, \n vector& path, vector>& result) {\n if (node == NULL) return;\n path.push_back(node->val);\n if (node->left == NULL && node->right == NULL) {\n if (node->val + value == sum) {\n result.push_back(path); \n }\n path.pop_back();\n return;\n }\n if (node->left) \n dfs(node->left, node->val + value, sum, path, result);\n if (node->right)\n dfs(node->right, node->val + value, sum, path, result);\n path.pop_back();\n }\n};" }, { "path": "PermutationSequence/PermutationSequence.cpp", "content": "\nconst int factorial[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};\n\nclass Solution {\npublic:\n string getPermutation(int n, int k) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n //\n // http://zh.wikipedia.org/wiki/%E5%BA%B7%E6%89%98%E5%B1%95%E5%BC%80\n //\n string sequence;\n bool hash[12];\n memset(hash, false, sizeof(hash));\n k -= 1;\n for (int i = n; i >= 1; i--) {\n int x = k / factorial[i-1];\n int count = 0;\n for (int j = 1; j <= n; j++) {\n if (!hash[j]) count += 1;\n if (count == x + 1) {\n x = j;\n break;\n }\n }\n k %= factorial[i-1];\n hash[x] = true;\n sequence += x + '0'; \n }\n return sequence;\n }\n};" }, { "path": "Permutations/Permutations.cpp", "content": "class Solution {\npublic:\n vector> permute(vector& num) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> result;\n dfs(num, 0, result);\n return move(result);\n }\n \n void dfs(vector& num, int step, vector>& result) {\n if (step == num.size()) {\n result.push_back(num);\n return;\n }\n for (int i = step; i < num.size(); i++) {\n swap(num[step], num[i]);\n dfs(num, step + 1, result);\n swap(num[i], num[step]);\n }\n }\n};" }, { "path": "PermutationsII/PermutationsII.cpp", "content": "class Solution {\npublic:\n vector > permuteUnique(vector &num) {\n vector> result;\n sort(num.begin(), num.end());\n do {\n result.push_back(num);\n } while (getNext(num));\n return result;\n }\n \n bool getNext(vector& num) {\n int i = num.size() - 1;\n while (i >= 1 && num[i-1] >= num[i]) {\n i--;\n }\n if (i == 0) {\n return false;\n }\n int j = num.size() - 1;\n while (j >= i) {\n if (num[j] > num[i-1]) {\n break;\n }\n j--;\n }\n swap(num[i-1], num[j]);\n reverse(num.begin() + i, num.end());\n return true;\n }\n};\n\n// recursive solution\nclass Solution {\npublic:\n void helper(vector>& result, vector& num, int x) {\n if (x == num.size()) {\n result.push_back(num);\n return;\n }\n helper(result, num, x + 1);\n map hash;\n hash[num[x]] = true;\n for (int i = x + 1; i < num.size(); i++) {\n if (hash[num[i]]) {\n continue;\n }\n hash[num[i]] = true;\n swap(num[x], num[i]);\n helper(result, num, x + 1);\n swap(num[x], num[i]);\n }\n }\n \n vector > permuteUnique(vector &num) {\n sort(num.begin(), num.end());\n vector> result;\n helper(result, num, 0);\n return move(result);\n }\n};\n" }, { "path": "PlusOne/PlusOne.cpp", "content": "class Solution {\npublic:\n vector plusOne(vector& digits) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int carry = 0;\n int size = digits.size();\n digits[size-1] += 1;\n \n for (int i = size - 1; i >= 0; i--) {\n int val = digits[i];\n digits[i] = (val + carry) % 10;\n carry = (val + carry) / 10;\n if (carry == 0) break;\n }\n if (carry) {\n digits.insert(digits.begin(), carry);\n }\n return digits;\n }\n};" }, { "path": "PopulatingNextRightPointersinEachNode/PopulatingNextRightPointersinEachNode.cpp", "content": "/**\n * Definition for binary tree with next pointer.\n * struct TreeLinkNode {\n * int val;\n * TreeLinkNode *left, *right, *next;\n * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n void connect(TreeLinkNode *root) {\n if (root == NULL) {\n return;\n }\n while (root->left) {\n TreeLinkNode* node = root;\n while (node) {\n node->left->next = node->right;\n if (node->next) {\n node->right->next = node->next->left;\n }\n node = node->next;\n }\n root = root->left;\n }\n }\n};\n" }, { "path": "PopulatingNextRightPointersinEachNodeII/PopulatingNextRightPointersinEachNodeII.cpp", "content": "/**\n * Definition for binary tree with next pointer.\n * struct TreeLinkNode {\n * int val;\n * TreeLinkNode *left, *right, *next;\n * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n void connect(TreeLinkNode *root) {\n if (root == NULL) {\n return;\n }\n TreeLinkNode* leftmost = root;\n while (leftmost) {\n TreeLinkNode* node = leftmost;\n TreeLinkNode* prev = NULL;\n leftmost = NULL;\n while (node) {\n if (node->left) {\n if (leftmost == NULL) {\n leftmost = node->left;\n }\n if (prev == NULL) {\n prev = node->left;\n } else {\n prev->next = node->left;\n prev = node->left;\n }\n }\n if (node->right) {\n if (leftmost == NULL) {\n leftmost = node->right;\n }\n if (prev == NULL) {\n prev = node->right;\n } else {\n prev->next = node->right;\n prev = node->right;\n }\n }\n node = node->next;\n }\n }\n }\n};\n" }, { "path": "Pow(x, n)/Pow(x, n).cpp", "content": "class Solution {\npublic:\n double pow(double x, int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n double result = 1.0;\n bool negative = false;\n if (n < 0) negative = true;\n while (n) {\n if (n & 1)\n result *= x;\n x *= x;\n n /= 2;\n }\n return negative ? (1.0 / result) : result;\n }\n};" }, { "path": "README.md", "content": "leetcode [![Total views](https://sourcegraph.com/api/repos/github.com/kedebug/leetcode/counters/views.png)](https://sourcegraph.com/github.com/kedebug/leetcode)\n============\n\nSolution set for LeetCode.\n\n\n\nThe commit message of each problem stands for it's difficulty index, which means:\n- 1 Easy\n- 2 Normal\n- 3 Medium\n- 4 Hard\n- 5 Much Harder\n\nIf you have found any method to optimize those solutions, please feel free to get in touch via kedebug0@gmail.com.\n\nLICENSE\n=============\nNo LICENSE, you can use it for any purpose.\n" }, { "path": "RecoverBinarySearchTree/RecoverBinarySearchTree.cpp", "content": "// O(n) time, O(1) space\nclass Solution {\npublic:\n void recoverTree(TreeNode *root) {\n TreeNode* node = root;\n TreeNode* prev = NULL;\n TreeNode* prev1 = NULL;\n TreeNode* curr1 = NULL;\n TreeNode* prev2 = NULL;\n TreeNode* curr2 = NULL;\n \n while (node != NULL) {\n if (node->left == NULL) {\n prev = node;\n node = node->right;\n } else {\n TreeNode* next = node->left;\n while (next->right && next->right != node) {\n next = next->right;\n }\n if (next->right == NULL) {\n next->right = node;\n node = node->left;\n } else {\n prev = node;\n node = node->right;\n next->right = NULL;\n }\n }\n if (prev && node && prev->val > node->val) {\n if (prev1 == NULL) {\n prev1 = prev, curr1 = node;\n } else {\n prev2 = prev, curr2 = node;\n }\n }\n }\n if (prev1 && curr2) {\n swap(prev1->val, curr2->val);\n } else {\n swap(prev1->val, curr1->val);\n }\n }\n};\n" }, { "path": "RegularExpressionMatching/RegularExpressionMatching.cpp", "content": "class Solution {\npublic:\n bool isMatch(const char *s, const char *p) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function \n\n if (s == NULL || p == NULL) \n return false;\n if (*p == '\\0') \n return *s == '\\0';\n \n if (*(p+1) == '*') {\n //\n // notice: \".*\" means repeat '.' 0 or more times\n //\n while ((*s != '\\0' && *p == '.') || *s == *p) {\n if (isMatch(s, p + 2))\n return true;\n s += 1;\n }\n return isMatch(s, p + 2);\n } \n else if ((*s != '\\0' && *p == '.') || *s == *p) {\n return isMatch(s + 1, p + 1);\n }\n return false;\n }\n};\n" }, { "path": "RemoveDuplicatesfromSortedArray/RemoveDuplicatesfromSortedArray.cpp", "content": "class Solution {\npublic:\n int removeDuplicates(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (n == 0) return 0;\n \n int low = 0;\n for (int high = 1; high < n; high++) {\n if (A[low] != A[high]) \n A[++low] = A[high];\n }\n return low + 1;\n }\n};" }, { "path": "RemoveDuplicatesfromSortedArrayII/RemoveDuplicatesfromSortedArrayII.cpp", "content": "class Solution {\npublic:\n int removeDuplicates(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (n == 0) return 0;\n \n int low = 0, high;\n int count = 1;\n for (high = 1; high < n; high++) {\n if (A[low] == A[high]) {\n if (count < 2) {\n count += 1;\n A[++low] = A[high];\n }\n }\n else {\n A[++low] = A[high];\n count = 1;\n }\n }\n return low + 1;\n }\n};" }, { "path": "RemoveDuplicatesfromSortedList/RemoveDuplicatesfromSortedList.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *deleteDuplicates(ListNode *head) {\n if (head == NULL) {\n return NULL;\n }\n ListNode* prev = head;\n ListNode* curr = head->next;\n while (curr) {\n if (prev->val != curr->val) {\n prev->next = curr;\n prev = prev->next;\n }\n curr = curr->next;\n }\n prev->next = NULL;\n return head;\n }\n};\n" }, { "path": "RemoveDuplicatesfromSortedListII/RemoveDuplicatesfromSortedListII.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *deleteDuplicates(ListNode *head) {\n ListNode prevhead(0);\n ListNode* prev = &prevhead;\n ListNode* curr = head;\n while (curr) {\n if (curr->next && curr->val == curr->next->val) {\n ListNode* next = curr->next;\n while (next && next->val == curr->val) {\n next = next->next;\n }\n curr = next;\n } else {\n prev->next = curr;\n prev = prev->next;\n curr = curr->next;\n }\n }\n prev->next = NULL;\n return prevhead.next;\n }\n};\n" }, { "path": "RemoveElement/RemoveElement.cpp", "content": "class Solution {\npublic:\n int removeElement(int A[], int n, int elem) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int low = -1, high;\n for (high = 0; high < n; high++) {\n if (A[high] != elem) {\n low += 1;\n A[low] = A[high];\n }\n }\n return low + 1;\n }\n};" }, { "path": "RemoveNthNodeFromEndofList/RemoveNthNodeFromEndofList.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *removeNthFromEnd(ListNode *head, int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n ListNode prevHead(0);\n prevHead.next = head;\n \n ListNode *prev = &prevHead;\n ListNode *slow = head;\n ListNode *fast = head;\n \n for (int i = 0; i < n; i++)\n fast = fast->next;\n \n while (fast != NULL) {\n prev = prev->next;\n slow = slow->next;\n fast = fast->next;\n }\n \n prev->next = slow->next;\n delete slow;\n return prevHead.next;\n }\n};" }, { "path": "RestoreIPAddresses/RestoreIPAddresses.cpp", "content": "class Solution {\npublic:\n vector restoreIpAddresses(string s) {\n vector result;\n vector sk;\n dfs(result, sk, s, 0, 0);\n return result;\n }\n \n void dfs(vector& result, vector& sk, const string& s, int val, int pos) {\n if (sk.size() > 4) {\n return;\n }\n \n if (pos == s.size()) {\n if (sk.size() < 4 || val != 0) {\n return;\n }\n string ip;\n ip += to_string(sk[0]);\n for (int i = 1; i < 4; i++) {\n ip += \".\";\n ip += to_string(sk[i]);\n }\n result.push_back(ip);\n return;\n }\n \n val = val * 10 + s[pos] - '0';\n if (val > 255) {\n return;\n }\n if (val != 0) {\n dfs(result, sk, s, val, pos + 1);\n }\n sk.push_back(val);\n dfs(result, sk, s, 0, pos + 1);\n sk.pop_back();\n }\n};\n" }, { "path": "ReverseInteger/ReverseInteger.cpp", "content": "class Solution {\npublic:\n int reverse(int x) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n bool minus = false;\n if (x < 0) {\n x = -x;\n minus = true;\n }\n int res = 0;\n while (x) {\n res *= 10;\n res += x % 10;\n x /= 10;\n }\n return minus ? (-res) : res;\n }\n};\n" }, { "path": "ReverseLinkedListII/ReverseLinkedListII.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *reverseBetween(ListNode *head, int m, int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n ListNode prev_head(0);\n prev_head.next = head;\n ListNode *prev = &prev_head;\n ListNode *current = head;\n \n for (int i = 0; i < m - 1; i++) {\n prev = prev->next;\n current = current->next;\n }\n ListNode *end = current;\n for (int i = m - 1; i < n; i++) {\n ListNode *next = current->next;\n current->next = prev->next;\n prev->next = current;\n current = next;\n }\n end->next = current;\n return prev_head.next;\n }\n};" }, { "path": "ReverseNodesink-Group/ReverseNodesink-Group.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *reverseKGroup(ListNode *head, int k) {\n ListNode* node = head;\n int len = 0;\n while (node) {\n len++;\n node = node->next;\n }\n if (k > len) {\n return head;\n }\n \n ListNode prevhead(0);\n prevhead.next = head;\n \n ListNode* curr = head;\n ListNode* prev = &prevhead;\n \n while (curr) {\n int count = k - 1;\n ListNode* last = curr;\n while (count && last) {\n count--;\n last = last->next;\n }\n if (count == 0 && last) {\n ListNode* next = last->next;\n last->next = NULL;\n ListNode* l = reverse(curr);\n curr->next = next;\n prev->next = l;\n prev = curr;\n curr = next;\n } else {\n break;\n }\n }\n return prevhead.next;\n }\n \n ListNode* reverse(ListNode* head) {\n ListNode prevhead(0);\n while (head) {\n ListNode* next = head->next;\n head->next = prevhead.next;\n prevhead.next = head;\n head = next;\n }\n return prevhead.next;\n }\n};\n" }, { "path": "ReverseWordsInAString/ReverseWordsInAString.cpp", "content": "class Solution {\npublic:\n void reverseWords(string &s) {\n int i = 0;\n int j = s.size() - 1;\n\n while (i < s.size() && s[i] == ' ') {\n i++;\n }\n while (j >= 0 && s[j] == ' ') {\n j--;\n }\n\n s = s.substr(i, j - i + 1);\n reverse(s, 0, s.size() - 1);\n \n for (i = 0, j = 0; j < s.size(); j++) {\n if (s[j] == ' ') {\n s[i++] = ' ';\n while (j+1 < s.size() && s[j+1] == ' ') {\n j++;\n }\n } else {\n s[i++] = s[j];\n }\n }\n s = s.substr(0, i);\n for (i = 0, j = 0; j < s.size(); j++) {\n if (s[j] == ' ') {\n reverse(s, i, j - 1);\n i = j + 1;\n }\n }\n \n if (i < s.size()) {\n reverse(s, i, s.size() - 1);\n }\n }\n \n void reverse(string& s, int i, int j) {\n while (i < j) {\n swap(s[i], s[j]);\n i++;\n j--;\n }\n }\n};\n\n// solution 2\nclass Solution {\npublic:\n void reverseWords(string &s) {\n string result;\n for (int i = 0, start = 0; i < s.size(); i++) {\n if (s[i] == ' ') {\n if (i > start) {\n result = s.substr(start, i - start) + \" \" + result;\n }\n start = i + 1;\n } else if (i == s.size() - 1) {\n result = s.substr(start, i + 1 - start) + \" \" + result;\n }\n }\n s = result.substr(0, result.size() - 1);\n }\n};\n" }, { "path": "RomantoInteger/RomantoInteger.cpp", "content": "class Solution {\npublic:\n int romanToInt(string s) {\n\t\t// Start typing your C/C++ solution below\n\t\t// DO NOT write int main() function\n\t\tint hash[256];\n\t\thash['I'] = 1; hash['V'] = 5; \n\t\thash['X'] = 10; hash['L'] = 50; \n\t\thash['C'] = 100; hash['D'] = 500;\n\t\thash['M'] = 1000;\n\n\t\tint result = 0;\n\t\tint num = 0;\n\t\tfor (size_t i = 0; i < s.size(); i++) {\n\t\t\tif (hash[s[i]] == num) {\n\t\t\t\tnum += hash[s[i]];\n\t\t\t} \n\t\t\telse if (hash[s[i]] > num) {\n\t\t\t\tif (num) {\n\t\t\t\t\tresult += hash[s[i]] - num;\n\t\t\t\t\tnum = 0;\n\t\t\t\t}\n\t\t\t\telse num = hash[s[i]];\n\t\t\t}\n\t\t\telse {\n\t\t\t\tresult += num;\n\t\t\t\tnum = hash[s[i]];\n\t\t\t}\n\t\t}\n\t\tif (num) result += num;\n\t\treturn result;\n\t}\n};" }, { "path": "RotateImage/RotateImage.cpp", "content": "class Solution {\npublic:\n void rotate(vector>& matrix) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int n = matrix.size();\n for (int i = 0; i < n / 2; i++) {\n for (int j = i; j < n - 1 - i; j++) {\n int x = matrix[i][j];\n matrix[i][j] = matrix[n-1-j][i];\n matrix[n-1-j][i] = matrix[n-1-i][n-1-j];\n matrix[n-1-i][n-1-j] = matrix[j][n-1-i];\n matrix[j][n-1-i] = x;\n }\n }\n }\n};" }, { "path": "RotateList/RotateList.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *rotateRight(ListNode *head, int k) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (head == NULL) return head;\n \n ListNode *node = head;\n int len = 0;\n while (node) {\n len += 1;\n node = node->next;\n }\n if (k >= len) \n k %= len;\n \n if (k == 0) \n return head;\n\n ListNode *slow = head;\n ListNode *fast = head;\n \n for (int i = 0; i < len - 1; i++)\n fast = fast->next;\n for (int i = 0; i < len - k - 1; i++)\n slow = slow->next;\n \n if (slow == fast)\n return head;\n \n ListNode *newHead = slow->next;\n slow->next = NULL;\n fast->next = head;\n return newHead;\n \n }\n};" }, { "path": "SameTree/SameTree.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool isSameTree(TreeNode *p, TreeNode *q) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (p == NULL && q == NULL)\n return true;\n if (p == NULL || q == NULL)\n return false;\n if (p->val == q->val) {\n bool flag = isSameTree(p->left, q->left);\n if (!flag) return false;\n return isSameTree(p->right, q->right);\n }\n return false;\n }\n};" }, { "path": "ScrambleString/ScrambleString.cpp", "content": "class Solution {\npublic:\n bool isScramble(string s1, string s2) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n return isScrambleHelper(s1, 0, s2, 0, s1.size());\n }\n \n bool isScrambleHelper(string& s1, int l1, string& s2, int l2, int size) {\n if (!canScramble(s1, l1, s2, l2, size)) return false; \n if (size == 1) return true;\n \n for (int i = 1; i < size; i++) {\n if (isScrambleHelper(s1, l1, s2, l2 + size - i, i) &&\n isScrambleHelper(s1, l1 + i, s2, l2, size - i))\n return true;\n if (isScrambleHelper(s1, l1, s2, l2, i) && \n isScrambleHelper(s1, l1 + i, s2, l2 + i, size - i))\n return true;\n }\n return false;\n }\n \n bool canScramble(string& s1, int l1, string& s2, int l2, int size) {\n int hash[26] = {0};\n for (int i = 0; i < size; i++) {\n hash[s1[l1 + i] - 'a'] += 1;\n hash[s2[l2 + i] - 'a'] -= 1;\n }\n for (int i = 0; i < 26; i++) {\n if (hash[i]) return false;\n }\n return true;\n }\n};" }, { "path": "SearchInsertPosition/SearchInsertPosition.cpp", "content": "class Solution {\npublic:\n int searchInsert(int A[], int n, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int low = 0, high = n - 1;\n while (low <= high) {\n int mid = low + (high - low) / 2;\n if (A[mid] == target)\n return mid;\n else if (A[mid] > target)\n high = mid - 1;\n else \n low = mid + 1;\n }\n return low;\n }\n};" }, { "path": "Searcha2DMatrix/Searcha2DMatrix.cpp", "content": "class Solution {\npublic:\n bool searchMatrix(vector>& matrix, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (matrix.empty()) return false;\n int lf = 0;\n int rt = matrix.size() - 1;\n int column = matrix[0].size();\n while (lf <= rt) {\n int m = (lf + rt) / 2;\n if (target < matrix[m][0]) {\n rt = m - 1;\n }\n else if (target > matrix[m][column-1]) {\n lf = m + 1;\n }\n else {\n return isValid(matrix[m], target);\n }\n }\n return false;\n }\n bool isValid(vector& row, int target) {\n int lf = 0;\n int rt = row.size() - 1;\n while (lf <= rt) {\n int m = (lf + rt) / 2;\n if (target == row[m]) {\n return true;\n }\n else if (target > row[m]) {\n lf = m + 1;\n }\n else {\n rt = m - 1;\n }\n }\n return false;\n }\n};" }, { "path": "SearchforaRange/SearchforaRange.cpp", "content": "class Solution {\npublic:\n vector searchRange(int A[], int n, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector range;\n range.push_back(find_lower_bound(A, n, target));\n range.push_back(find_upper_bound(A, n, target));\n return range;\n }\n \n int find_lower_bound(int A[], int n, int target) {\n int left = 0, right = n - 1;\n while (left <= right) {\n int mid = left + (right - left) / 2;\n if (A[mid] >= target) {\n right = mid - 1;\n }\n else {\n left = mid + 1;\n }\n }\n if (A[left] == target)\n return left;\n return -1;\n }\n \n int find_upper_bound(int A[], int n, int target) {\n int left = 0, right = n - 1;\n while (left <= right) {\n int mid = left + (right - left) / 2;\n if (A[mid] <= target) {\n left = mid + 1;\n }\n else {\n right = mid - 1;\n }\n }\n if (A[right] == target)\n return right;\n return -1;\n }\n};" }, { "path": "SearchinRotatedSortedArray/SearchinRotatedSortedArray.cpp", "content": "class Solution {\npublic:\n int search(int A[], int n, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int lf = 0, rt = n - 1;\n while (lf <= rt) {\n int m = lf + (rt - lf) / 2;\n if (A[m] == target)\n return m;\n \n if (A[lf] <= A[m]) {\n if (A[lf] <= target && target < A[m])\n rt = m - 1;\n else\n lf = m + 1;\n }\n else {\n if (A[m] < target && target <= A[rt])\n lf = m + 1;\n else\n rt = m - 1;\n }\n }\n return -1;\n }\n};" }, { "path": "SearchinRotatedSortedArrayII/SearchinRotatedSortedArrayII.cpp", "content": "class Solution {\npublic:\n bool search(int A[], int n, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int lf = 0, rt = n - 1;\n while (lf <= rt) {\n int m = lf + (rt - lf) / 2;\n if (A[m] == target)\n return true;\n \n if (A[lf] < A[m]) {\n if (A[lf] <= target && target < A[m])\n rt = m - 1;\n else\n lf = m + 1;\n }\n else if (A[lf] > A[m]) {\n if (A[m] < target && target <= A[rt])\n lf = m + 1;\n else\n rt = m - 1;\n }\n else {\n bool onleft = search(A + lf + 1, m - lf - 1, target);\n if (onleft) return true;\n return search(A + m + 1, rt - m, target);\n } \n \n }\n return false;\n }\n};" }, { "path": "SetMatrixZeroes/SetMatrixZeroes.cpp", "content": "class Solution {\npublic:\n void setZeroes(vector>& matrix) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (matrix.empty()) return;\n \n bool rowzero = false;\n bool colzero = false;\n int row = matrix.size();\n int col = matrix[0].size();\n \n for (int i = 0; i < row; i++) {\n if (matrix[i][0] == 0) colzero = true;\n }\n for (int i = 0; i < col; i++) {\n if (matrix[0][i] == 0) rowzero = true;\n }\n for (int i = 1; i < row; i++) {\n for (int j = 1; j < col; j++) {\n if (matrix[i][j] == 0) {\n matrix[i][0] = matrix[0][j] = 0;\n }\n }\n }\n for (int i = 1; i < row; i++) {\n if (matrix[i][0] == 0) {\n for (int j = 1; j < col; j++)\n matrix[i][j] = 0;\n }\n }\n for (int j = 1; j < col; j++) {\n if (matrix[0][j] == 0) {\n for (int i = 1; i < row; i++)\n matrix[i][j] = 0;\n }\n }\n if (rowzero) {\n for (int j = 0; j < col; j++)\n matrix[0][j] = 0;\n }\n if (colzero) {\n for (int i = 0; i < row; i++)\n matrix[i][0] = 0;\n }\n }\n};" }, { "path": "SimplifyPath/SimplifyPath.cpp", "content": "class Solution {\npublic:\n string simplifyPath(string path) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector path_stack;\n int i = 0;\n while (i < path.size()) {\n while (i < path.size() && path[i] == '/') i += 1;\n if (i == path.size()) break;\n string directory;\n while (i < path.size() && path[i] != '/') {\n directory += path[i];\n i += 1;\n }\n if (directory == \"..\") {\n if (!path_stack.empty())\n path_stack.pop_back();\n }\n else if (directory != \".\") {\n path_stack.push_back(directory);\n }\n }\n if (path_stack.empty()) \n return \"/\";\n string simplified_path;\n for (int i = 0; i < path_stack.size(); i++)\n simplified_path += \"/\" + path_stack[i];\n return simplified_path;\n }\n};" }, { "path": "SortColors/SortColors.cpp", "content": "class Solution {\npublic:\n void sortColors(int A[], int n) {\n int p0 = -1;\n int p1 = 0;\n int p2 = n;\n while (p1 < p2) {\n if (A[p1] == 1) {\n p1++;\n } else if (A[p1] == 0) {\n swap(A[p0+1], A[p1]);\n p0++;\n p1++;\n } else {\n swap(A[p1], A[p2-1]);\n p2--;\n }\n }\n }\n};\n\n//\n// Solution2 using the method like quicksort\n//\nclass Solution2 {\npublic:\n void sortColors(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int p = split(A, 0, n - 1, 0);\n split(A, p + 1, n - 1, 1);\n }\n int split(int A[], int low, int high, int pivot) {\n int i = low - 1;\n for (int j = low; j <= high; j++) {\n if (A[j] <= pivot) {\n i += 1;\n if (i != j) swap(A[i], A[j]);\n }\n }\n return i;\n }\n};\n" }, { "path": "SortList/SortList.cc", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *sortList(ListNode *head) {\n if (head == NULL || head->next == NULL) {\n return head;\n }\n \n ListNode new_head(0);\n new_head.next = head;\n \n ListNode* one = &new_head;\n ListNode* two = &new_head;\n \n while (two && two->next) {\n one = one->next;\n two = two->next->next;\n }\n \n ListNode* node = one->next;\n one->next = NULL;\n ListNode* left = sortList(new_head.next);\n ListNode* right = sortList(node);\n \n \n ListNode* sorted_head = NULL;\n ListNode* sorted_curr = NULL;\n \n if (left->val < right->val) {\n sorted_head = sorted_curr = left;\n left = left->next;\n } else {\n sorted_head = sorted_curr = right;\n right = right->next;\n }\n \n while (left && right) {\n if (left->val < right->val) {\n sorted_curr->next = left;\n sorted_curr = left;\n left = left->next;\n } else {\n sorted_curr->next = right;\n sorted_curr = right;\n right = right->next;\n }\n }\n \n while (left) {\n sorted_curr->next = left;\n sorted_curr = left;\n left = left->next;\n }\n while (right) {\n sorted_curr->next = right;\n sorted_curr = right;\n right = right->next;\n }\n \n sorted_curr->next = NULL;\n return sorted_head;\n }\n};\n" }, { "path": "SpiralMatrix/SpiralMatrix.cpp", "content": "class Solution {\npublic:\n\tvector spiralOrder(vector > &matrix) {\n vector result;\n if (matrix.empty()) {\n return result;\n }\n int row = matrix.size();\n int col = matrix[0].size() + 1;\n int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};\n int x = 0;\n int y = -1;\n int k = 0;\n int count = 0;\n bool horizon = true;\n while (count < matrix.size() * matrix[0].size()) {\n int dx = dir[k%4][0];\n int dy = dir[k%4][1];\n k++;\n \n if (horizon) {\n horizon = false;\n col--;\n for (int i = 0; i < col; i++, count++) {\n x += dx;\n y += dy;\n result.push_back(matrix[x][y]);\n }\n } else {\n horizon = true;\n row--;\n for (int i = 0; i < row; i++, count++) {\n x += dx;\n y += dy;\n result.push_back(matrix[x][y]);\n }\n }\n }\n return result;\n\t}\n};\n" }, { "path": "SpiralMatrixII/SpiralMatrixII.cpp", "content": "class Solution {\npublic:\n vector > generateMatrix(int n) {\n vector> matrix(n, vector(n, 0));\n int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};\n int x = 0;\n int y = -1;\n int k = 0;\n int count = 0;\n int horizon = true;\n int row = n;\n int col = n + 1;\n while (count < n * n) {\n int dx = dir[k%4][0];\n int dy = dir[k%4][1];\n k++;\n if (horizon) {\n horizon = false;\n col--;\n for (int i = 0; i < col; i++) {\n x += dx;\n y += dy;\n count++;\n matrix[x][y] = count;\n }\n } else {\n horizon = true;\n row--;\n for (int i = 0; i < row; i++) {\n x += dx;\n y += dy;\n count++;\n matrix[x][y] = count;\n }\n }\n }\n return matrix;\n }\n};\n" }, { "path": "Sqrt(x)/Sqrt(x).cpp", "content": "class Solution {\npublic:\n int sqrt(int x) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n long long lf = 0;\n long long rt = x;\n while (lf <= rt) {\n long long m = (lf + rt) >> 1;\n long long sq = m * m;\n if (sq == (long long)x)\n return m;\n else if (sq < (long long)x)\n lf = m + 1;\n else \n rt = m - 1;\n }\n return (int)rt;\n }\n};" }, { "path": "StringtoInteger(atoi)/StringtoInteger(atoi).cpp", "content": "class Solution {\npublic:\n int atoi(const char *str) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (str == NULL)\n return 0;\n while (*str == ' ') {\n str++;\n }\n bool minus = false;\n if (*str == '+') {\n str++;\n } else if (*str == '-') {\n str++;\n minus = true;\n }\n long long int value = 0;\n for (; *str != '\\0'; str++) {\n if ('0' <= *str && *str <= '9') {\n value *= 10;\n value += *str - '0';\n } else {\n break;\n }\n }\n if (minus)\n value = -value;\n if (value > INT_MAX)\n value = INT_MAX;\n if (value < INT_MIN)\n value = INT_MIN;\n return (int)value;\n }\n};\n" }, { "path": "Subsets/Subsets.cpp", "content": "class Solution {\npublic:\n vector > subsets(vector& S) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> result;\n vector subset;\n \n sort(S.begin(), S.end());\n DFS(subset, 0, S, result);\n return move(result);\n }\n \n void DFS(vector& subset, int step, vector& S, vector>& result) {\n if (step == S.size()) {\n result.push_back(subset);\n return;\n }\n subset.push_back(S[step]);\n DFS(subset, step + 1, S, result);\n subset.pop_back();\n \n DFS(subset, step + 1, S, result);\n }\n};" }, { "path": "SubsetsII/SubsetsII.cpp", "content": "class Solution {\npublic:\n vector> subsetsWithDup(vector& S) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n \n vector> subsets;\n vector integers;\n \n if (S.empty()) return subsets;\n \n sort(S.begin(), S.end());\n DFS(integers, 0, S, subsets);\n \n return move(subsets);\n }\n \n void DFS(vector& integers, int start, vector& S, vector>& subsets) {\n if (start == S.size()) {\n subsets.push_back(integers);\n return;\n }\n int end = start;\n while (end + 1 < S.size() && S[start] == S[end+1])\n end += 1;\n \n DFS(integers, end + 1, S, subsets);\n \n for (int i = start; i <= end; i++) {\n integers.push_back(S[i]);\n DFS(integers, end + 1, S, subsets);\n }\n for (int i = start; i <= end; i++)\n integers.pop_back();\n }\n};" }, { "path": "SubstringwithConcatenationofAllWords/SubstringwithConcatenationofAllWords.cpp", "content": "class Solution {\npublic:\n vector findSubstring(string S, vector &L) {\n vector result;\n if (L.empty()) {\n return result;\n }\n int n = L.size();\n int len = L[0].size();\n map hash;\n for (int i = 0; i < n; i++) {\n hash[L[i]] += 1;\n }\n for (int i = 0; i < len; i++) {\n vector slices;\n for (int j = i; j + len <= S.size(); j += len) {\n slices.push_back(S.substr(j, len));\n }\n for (int j = 0; j + n <= slices.size(); j++) {\n map found;\n for (int k = 0; k < n; k++) {\n found[slices[j+k]] += 1;\n if (found[slices[j+k]] > hash[slices[j+k]]) {\n break;\n }\n if (k == n - 1) {\n result.push_back(i + j * len);\n }\n }\n }\n }\n return result;\n }\n};\n" }, { "path": "SudokuSolver/SudokuSolver.cpp", "content": "class Solution {\npublic:\n bool visited_cells[20][20];\n bool visited_row[20][20];\n bool visited_col[20][20];\n \n void solveSudoku(vector>& board) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n memset(visited_cells, false, sizeof(visited_cells)); \n memset(visited_row, false, sizeof(visited_row)); \n memset(visited_col, false, sizeof(visited_col)); \n \n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (board[i][j] != '.') {\n int cell = (i / 3) * 3 + j / 3;\n int x = board[i][j] - '0';\n visited_cells[cell][x] = true;\n visited_row[i][x] = visited_col[j][x] = true;\n }\n }\n }\n \n isValidSudokuHelper(board, 0);\n }\n \n bool isValidSudokuHelper(vector>& board, int step) {\n if (step == 81) return true;\n \n int row = step / 9;\n int col = step % 9;\n int cell = (row / 3) * 3 + col / 3;\n \n if (board[row][col] != '.') {\n return isValidSudokuHelper(board, step + 1);\n }\n for (int i = 1; i <= 9; i++) {\n if (!visited_cells[cell][i] && !visited_row[row][i] && !visited_col[col][i]) {\n visited_cells[cell][i] = true;\n visited_row[row][i] = visited_col[col][i] = true;\n board[row][col] = '0' + i;\n bool flag = isValidSudokuHelper(board, step + 1);\n if (flag) return true;\n board[row][col] = '.';\n visited_cells[cell][i] = false;\n visited_row[row][i] = visited_col[col][i] = false;\n }\n }\n return false;\n }\n};\n\n" }, { "path": "SumRoottoLeafNumbers/SumRoottoLeafNumbers.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n int sumNumbers(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n int sum = 0;\n dfs(root, 0, sum);\n return sum;\n \n }\n void dfs(TreeNode *node, int val, int& sum) {\n if (node == NULL) return;\n \n val *= 10;\n val += node->val;\n \n if (node->left == NULL && node->right == NULL) {\n sum += val;\n return;\n }\n \n if (node->left) {\n dfs(node->left, val, sum);\n }\n if (node->right) {\n dfs(node->right, val, sum);\n }\n }\n};\n" }, { "path": "SurroundedRegions/SurroundedRegions.cpp", "content": "\nconst int dx[4] = {0, 0, 1, -1};\nconst int dy[4] = {1, -1, 0, 0};\n\nclass Solution {\npublic:\n\tvoid solve(vector> &board) {\n\t\t// Start typing your C/C++ solution below\n\t\t// DO NOT write int main() function\n\t\t\n\t\tif (board.empty()) return;\n\t\t\n\t\trow = board.size();\n\t\tcol = board[0].size();\n\n\t\tfor (int i = 0; i < row; i++) {\n\t\t\tif (board[i][0] == 'O') dfs(i, 0, board);\n\t\t\tif (board[i][col-1] == 'O') dfs(i, col-1, board);\n\t\t}\n\t\tfor (int j = 1; j < col; j++) {\n\t\t\tif (board[0][j] == 'O') dfs(0, j, board);\n\t\t\tif (board[row-1][j] == 'O') dfs(row-1, j, board);\n\t\t}\n\t\tfor (int i = 0; i < row; i++) {\n\t\t\tfor (int j = 0; j < col; j++) {\n\t\t\t\tif (board[i][j] == 'O') board[i][j] = 'X';\n\t\t\t\telse if (board[i][j] == 'B') board[i][j] = 'O';\n\t\t\t}\n\t\t}\n\t}\n\n\tvoid dfs(int x, int y, vector> &board) {\n\t\tboard[x][y] = 'B';\n\n\t\tfor (int k = 0; k < 4; k++) {\n\t\t\tint i = x + dx[k];\n\t\t\tint j = y + dy[k];\n\t\t\tif (check(i, j) && board[i][j] == 'O') {\n\t\t\t\tdfs(i, j, board);\n\t\t\t}\n\t\t}\n\t}\n\n\tbool check(int x, int y) {\n\t\tif (x >= 0 && x < row && y >= 0 && y < col) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\nprivate:\n\tint row, col;\n};\n" }, { "path": "SwapNodesinPairs/SwapNodesinPairs.cpp", "content": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode(int x) : val(x), next(NULL) {}\n * };\n */\nclass Solution {\npublic:\n ListNode *swapPairs(ListNode *head) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (head == NULL) return NULL;\n \n ListNode prevHead(0);\n prevHead.next = head;\n ListNode *prev = &prevHead;\n ListNode *left = head;\n ListNode *right = head->next;\n \n while (left && right) {\n prev->next = right;\n left->next = right->next;\n right->next = left;\n \n prev = left;\n left = left->next;\n if (left) right = left->next;\n else right = NULL;\n }\n return prevHead.next;\n }\n};" }, { "path": "SymmetricTree/SymmetricTree_iteratively.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool isSymmetric(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (root == NULL)\n return true;\n queue lhs, rhs;\n lhs.push(root->left);\n rhs.push(root->right);\n while (!lhs.empty() && !rhs.empty()) {\n TreeNode *l = lhs.front(); lhs.pop();\n TreeNode *r = rhs.front(); rhs.pop();\n if (l == NULL && r == NULL) continue;\n if (l == NULL || r == NULL) return false;\n if (l->val != r->val) return false;\n lhs.push(l->left); lhs.push(l->right);\n rhs.push(r->right); rhs.push(r->left);\n }\n if (lhs.empty() && rhs.empty())\n return true;\n else\n return false;\n }\n};" }, { "path": "SymmetricTree/SymmetricTree_recursively.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool isSymmetric(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n if (root == NULL)\n return true;\n return dfs(root->left, root->right);\n \n }\n bool dfs(TreeNode *lhs, TreeNode *rhs) {\n if (lhs == NULL && rhs == NULL)\n return true;\n if (lhs == NULL || rhs == NULL)\n return false;\n \n if (lhs->val == rhs->val) {\n bool flag = dfs(lhs->left, rhs->right);\n if (!flag) return false;\n return dfs(lhs->right, rhs->left);\n }\n return false;\n }\n};" }, { "path": "TextJustification/TextJustification.cpp", "content": "class Solution {\npublic:\n vector fullJustify(vector& words, int L) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector needed_lines(words.size(), 0);\n int count_line = 1;\n int len = 0;\n for (int i = 0; i < words.size(); i++) {\n if (len + words[i].size() + 1 <= L + 1) {\n needed_lines[i] = count_line;\n len += words[i].size() + 1;\n }\n else {\n count_line += 1;\n len = words[i].size() + 1;\n needed_lines[i] = count_line;\n }\n }\n vector justified;\n int start = 0;\n \n while (start < words.size()) {\n int end = start + 1;\n int words_len = words[start].size();\n while (end < words.size() && needed_lines[start] == needed_lines[end]) {\n words_len += words[end].size();\n end += 1;\n }\n int words_num = end - start;\n string justified_line;\n if (words_num == 1) {\n justified_line += words[start];\n justified_line.append(L - words_len, ' ');\n }\n else {\n int extra = (L - words_len) % (words_num - 1);\n int blank = (L - words_len) / (words_num - 1);\n if (end == words.size()) {\n extra = 0; blank = 1;\n }\n for (int i = start; i < end; i++) {\n justified_line += words[i];\n if (i == end -1) continue;\n if (extra > 0) {\n justified_line.append(blank + 1, ' ');\n extra -= 1;\n }\n else\n justified_line.append(blank, ' ');\n }\n if (end == words.size()) {\n justified_line.append(L - words_len - words_num + 1, ' ');\n }\n }\n justified.push_back(justified_line);\n start = end;\n }\n return justified;\n }\n};" }, { "path": "TrappingRainWater/TrappingRainWater.cpp", "content": "// O(n) time, O(n) space\nclass Solution {\npublic:\n int trap(int A[], int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int max_from_left[n];\n int max_from_right[n];\n \n max_from_left[0] = A[0];\n for (int i = 1; i < n; i++)\n max_from_left[i] = max(max_from_left[i-1], A[i]);\n \n max_from_right[n-1] = A[n-1];\n for (int i = n - 2; i >= 0; i--)\n max_from_right[i] = max(max_from_right[i+1], A[i]);\n \n int water = 0;\n for (int i = 1; i < n - 1; i++) {\n int min_height = min(max_from_left[i-1], max_from_right[i+1]);\n if (min_height > A[i])\n water += min_height - A[i];\n }\n return water;\n }\n};\n\n// O(n) time, O(1) space\nclass Solution {\npublic:\n int trap(int A[], int n) {\n int maxh = 0;\n int water = 0;\n int temp = 0;\n for (int i = 0; i < n; i++) {\n if (A[i] <= maxh) {\n temp += maxh - A[i];\n } else {\n maxh = A[i];\n water += temp;\n temp = 0;\n }\n }\n maxh = 0;\n temp = 0;\n for (int i = n - 1; i >= 0; i--) {\n if (A[i] < maxh) {\n temp += maxh - A[i];\n } else {\n maxh = A[i];\n water += temp;\n temp = 0;\n }\n }\n return water;\n }\n};\n" }, { "path": "Triangle/Triangle.cpp", "content": "class Solution {\npublic:\n int minimumTotal(vector > &triangle) {\n int level = triangle.size();\n vector dp(level + 1, 0);\n for (int i = level - 1; i >= 0; i--) {\n for (int j = 0; j <= i; j++) {\n dp[j] = triangle[i][j] + min(dp[j], dp[j+1]);\n }\n }\n return dp[0];\n }\n};\n" }, { "path": "TwoSum/TwoSum.cpp", "content": "bool lessthan(const pair& lhs, const pair& rhs) {\n if (lhs.first == rhs.first) \n return lhs.second < rhs.second;\n return lhs.first < rhs.first;\n}\n\nclass Solution {\npublic:\n vector twoSum(vector &numbers, int target) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> vnum;\n for (size_t i = 0; i < numbers.size(); i++) {\n vnum.push_back(make_pair(numbers[i], i + 1));\n }\n sort(vnum.begin(), vnum.end(), lessthan);\n vector ans;\n int s = 0, e = vnum.size() - 1;\n while (s < e) {\n if (vnum[s].first + vnum[e].first == target) {\n ans.push_back(min(vnum[s].second, vnum[e].second));\n ans.push_back(max(vnum[s].second, vnum[e].second));\n break;\n } \n else if (vnum[s].first + vnum[e].first > target)\n e -= 1;\n else \n s += 1;\n }\n return ans;\n }\n};\n" }, { "path": "UniqueBinarySearchTrees/UniqueBinarySearchTrees.cpp", "content": "class Solution {\npublic:\n int numTrees(int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector dp(n + 1, 0);\n dp[0] = dp[1] = 1;\n for (int i = 2; i <= n; i++) {\n for (int j = 0; j < i; j++)\n dp[i] += dp[j] * dp[i-j-1];\n }\n return dp[n];\n }\n};" }, { "path": "UniqueBinarySearchTreesII/UniqueBinarySearchTreesII.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n vector generateTrees(int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n return generateTreesHelper(1, n);\n }\n \n vector generateTreesHelper(int left, int right) {\n vector trees;\n if (left > right) {\n trees.push_back(NULL);\n return trees;\n }\n for (int r = left; r <= right; r++) {\n vector left_trees = generateTreesHelper(left, r - 1);\n vector right_trees = generateTreesHelper(r + 1, right);\n for (int i = 0; i < left_trees.size(); i++) {\n for (int j = 0; j < right_trees.size(); j++) {\n TreeNode *root = new TreeNode(r);\n root->left = left_trees[i];\n root->right = right_trees[j];\n trees.push_back(root);\n }\n }\n }\n return trees;\n }\n};" }, { "path": "UniquePaths/UniquePaths.cpp", "content": "class Solution {\npublic:\n int uniquePaths(int m, int n) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n vector> dp(m, vector(n, 0));\n for (int i = 0; i < m; i++)\n dp[i][0] = 1;\n for (int j = 0; j < n; j++)\n dp[0][j] = 1;\n for (int i = 1; i < m; i++) {\n for (int j = 1; j < n; j++) \n dp[i][j] = dp[i-1][j] + dp[i][j-1];\n }\n return dp[m-1][n-1];\n }\n};" }, { "path": "UniquePathsII/UniquePathsII.cpp", "content": "class Solution {\npublic:\n int uniquePathsWithObstacles(vector>& obstacleGrid) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int m = obstacleGrid.size();\n if (m == 0) return 0;\n int n = obstacleGrid[0].size();\n \n vector> dp(m, vector(n, 0));\n \n for (int i = 0; i < m; i++) {\n if (obstacleGrid[i][0] == 0) \n dp[i][0] = 1;\n else\n break;\n }\n for (int j = 0; j < n; j++) {\n if (obstacleGrid[0][j] == 0) \n dp[0][j] = 1;\n else\n break;\n }\n for (int i = 1; i < m; i++) {\n for (int j = 1; j < n; j++) {\n if (obstacleGrid[i][j] == 0)\n dp[i][j] = dp[i-1][j] + dp[i][j-1];\n }\n }\n return dp[m-1][n-1];\n \n }\n};" }, { "path": "ValidNumber/ValidNumber.cpp", "content": "// NFA\nclass Solution {\npublic:\n bool accept(const char* s, int& i, string expected) {\n for (int j = 0; j < expected.size(); j++) {\n if (s[i] == expected[j]) {\n i += 1;\n return true;\n }\n }\n return false;\n }\n \n bool acceptRun(const char* s, int& i, string expected) {\n bool found = false;\n int count = 0;\n while (s[i] != '\\0') {\n found = false;\n for (int j = 0; j < expected.size(); j++) {\n if (s[i] == expected[j]) {\n i++;\n count++;\n found = true;\n }\n }\n if (!found) {\n break;\n }\n }\n if (count > 0) {\n return true;\n }\n return false;\n }\n\n bool isNumber(const char *s) {\n string digits(\"0123456789\");\n \n int i = 0;\n \n acceptRun(s, i, \" \");\n \n bool beforedot = false;\n bool afterdot = false;\n \n accept(s, i, \"+-\");\n beforedot = acceptRun(s, i, digits);\n \n if (accept(s, i, \".\")) {\n if (acceptRun(s, i, digits)) {\n afterdot = true;\n }\n }\n \n if (!beforedot && !afterdot) {\n return false;\n }\n \n if (accept(s, i, \"eE\")) {\n accept(s, i, \"+-\");\n if (!acceptRun(s, i, digits)) {\n return false;\n }\n }\n \n while (s[i] != '\\0') {\n if (s[i] != ' ') {\n return false;\n }\n i++;\n }\n return true;\n }\n};\n" }, { "path": "ValidPalindrome/ValidPalindrome.cpp", "content": "class Solution {\npublic:\n bool isPalindrome(string s) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n string alphas;\n \n for (size_t i = 0; i < s.size(); i++) {\n if ('A' <= s[i] && s[i] <= 'Z') \n alphas += s[i] - 'A' + 'a';\n else if ('a' <= s[i] && s[i] <= 'z')\n alphas += s[i];\n else if ('0' <= s[i] && s[i] <= '9')\n alphas += s[i];\n }\n \n if (alphas.size() == 0)\n return true;\n \n size_t beg = 0, end = alphas.size() - 1;\n \n while (beg < end) {\n if (alphas[beg] == alphas[end]) {\n beg += 1;\n end -= 1;\n } else {\n return false;\n }\n }\n return true;\n }\n};\n" }, { "path": "ValidParentheses/ValidParentheses.cpp", "content": "class Solution {\npublic:\n bool isValid(string s) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n int n = s.size();\n char stack[n];\n int size = 0;\n int hash[256];\n \n hash['('] = 0, hash['{'] = 1, hash['['] = 2;\n hash[')'] = 3, hash['}'] = 4, hash[']'] = 5;\n \n \n for (int i = 0; i < n; i++) {\n if (hash[s[i]] < 3)\n stack[size++] = s[i];\n else {\n if (size == 0) return false;\n if ((hash[s[i]] % 3) != hash[stack[size-1]]) return false;\n size -= 1;\n }\n }\n return size ? false : true;\n }\n};" }, { "path": "ValidSudoku/ValidSudoku.cpp", "content": "class Solution {\npublic:\n bool isValidSudoku(vector> &board) {\n vector> rows(9, vector(9, false));\n vector> cols(9, vector(9, false));\n vector> cells(9, vector(9, false));\n \n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (board[i][j] != '.') {\n int x = board[i][j] - '1';\n if (rows[i][x] || cols[j][x] || cells[(j/3)*3+i/3][x]) {\n return false;\n }\n rows[i][x] = true;\n cols[j][x] = true;\n cells[(j/3)*3+i/3][x] = true;\n }\n }\n }\n return true;\n }\n};\n" }, { "path": "ValidateBinarySearchTree/ValidateBinarySearchTree.cpp", "content": "/**\n * Definition for binary tree\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode(int x) : val(x), left(NULL), right(NULL) {}\n * };\n */\nclass Solution {\npublic:\n bool isValidBST(TreeNode *root) {\n if (root == NULL)\n return true;\n \n return valid(root->left, INT_MIN, root->val) && \n valid(root->right, root->val, INT_MAX);\n }\n \n bool valid(TreeNode *node, int start, int limit) {\n if (node == NULL)\n return true;\n \n if (node->val >= limit || node->val <= start)\n return false;\n \n return valid(node->left, start, node->val) &&\n valid(node->right, node->val, limit);\n }\n};\n\n//\n// Solution 2, O(1) space\n//\nclass Solution {\npublic:\n bool isValidBST(TreeNode *root) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n TreeNode *parent = NULL;\n TreeNode *current = root;\n bool flag = true;\n \n while (current != NULL) {\n if (current->left == NULL) {\n if (parent && parent->val >= current->val)\n flag = false; \n \n parent = current;\n current = current->right;\n }\n else {\n TreeNode *left_right_most = current->left;\n while (left_right_most->right && left_right_most->right != current)\n left_right_most = left_right_most->right;\n \n if (left_right_most->right == NULL) {\n left_right_most->right = current;\n current = current->left;\n }\n else {\n if (parent && parent->val >= current->val)\n flag = false;\n \n left_right_most->right = NULL;\n parent = current;\n current = current->right;\n }\n }\n }\n return flag;\n }\n};\n// http://fisherlei.blogspot.com/2012/12/leetcode-recover-binary-search-tree.html\n" }, { "path": "WildcardMatching/WildcardMatching.cpp", "content": "class Solution {\npublic:\n bool isMatch(const char *s, const char *p) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n if (s == NULL || p == NULL)\n return false;\n \n int slen = strlen(s);\n int plen = strlen(p);\n \n int count_char = 0;\n for (int i = 0; i < plen; i++) {\n if (p[i] != '*') \n count_char += 1;\n }\n \n if (count_char > slen)\n return false;\n \n bool matches[slen + 1];\n memset(matches, false, sizeof(bool)*(slen+1));\n int first_match = 0;\n matches[first_match] = true;\n \n for (int i = 0; i < plen; i++) {\n if (i > 0 && p[i] == '*' && p[i-1] == '*')\n continue;\n if (p[i] == '*') {\n for (int j = first_match + 1; j <= slen; j++)\n matches[j] = true;\n } else {\n int match_id = -1;\n for (int j = slen; j > first_match; j--) {\n matches[j] = (s[j-1] == p[i] || p[i] == '?') && matches[j-1];\n if (matches[j]) \n match_id = j;\n }\n if (match_id != -1) \n first_match = match_id;\n else\n return false;\n }\n }\n return matches[slen];\n }\n};" }, { "path": "WordLadder/WordLadder.cpp", "content": "class Solution {\npublic:\n int ladderLength(string start, string end, unordered_set &dict) {\n queue q;\n unordered_map visited;\n map steps;\n\n q.push(start);\n visited[start] = true;\n while (!q.empty()) {\n string u = q.front();\n q.pop();\n if (u == end) {\n int count = 1;\n while (steps.find(u) != steps.end()) {\n u = steps[u];\n count++;\n }\n return count;\n }\n string v = u;\n for (int i = 0; i < v.size(); i++) {\n for (char c = 'a'; c <= 'z'; c++) {\n v[i] = c;\n if (visited.find(v) == visited.end() \n && dict.find(v) != dict.end()) {\n visited[v] = true;\n steps[v] = u;\n q.push(v);\n }\n }\n v[i] = u[i];\n }\n }\n return 0;\n }\n};\n" }, { "path": "WordLadderII/WordLadderII.cpp", "content": "class Solution {\nprivate:\n vector vdict;\n vector> map;\n vector> prev;\n\n void buildMap(const unordered_set& dict) {\n vdict.clear();\n unordered_map unmap;\n for (auto iter = dict.begin(); iter != dict.end(); iter++) {\n unmap[*iter] = vdict.size();\n vdict.push_back(*iter);\n }\n \n map.clear();\n map.resize(vdict.size());\n for (size_t i = 0; i < vdict.size(); i++) {\n string word = vdict[i];\n for (size_t j = 0; j < word.size(); j++) {\n for (char c = 'a'; c <= 'z'; c++) {\n if (c == vdict[i][j]) continue;\n word[j] = c;\n if (unmap.count(word)) {\n map[i].push_back(unmap[word]);\n }\n word[j] = vdict[i][j];\n }\n }\n }\n }\n\n void buildReverseMap(int src, int dst) {\n prev.clear();\n prev.resize(vdict.size());\n vector dist(vdict.size());\n queue Q;\n Q.push(src);\n dist[src] = 0;\n while (!Q.empty()) {\n src = Q.front(); Q.pop();\n if (src == dst) break;\n for (size_t i = 0; i < map[src].size(); i++) {\n int v = map[src][i];\n if (prev[v].size() == 0) {\n prev[v].push_back(src);\n dist[v] = dist[src] + 1;\n Q.push(v);\n } else if (dist[v] == dist[src] + 1) {\n prev[v].push_back(src);\n }\n }\n }\n }\n\n void dfs(int u, int v, vector& path, vector>& result) {\n path.push_back(v);\n if (u == v && path.size()) {\n vector pathstring;\n for (auto iter = path.rbegin(); iter != path.rend(); iter++) {\n pathstring.push_back(vdict[*iter]);\n }\n result.push_back(pathstring);\n } else {\n for (size_t i = 0; i < prev[v].size(); i++)\n dfs(u, prev[v][i], path, result);\n }\n path.pop_back();\n }\n \npublic:\n vector> findLadders(string start, string end, unordered_set &dict) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n dict.insert(start);\n dict.insert(end);\n\n buildMap(dict);\n\n int src, dst;\n for (src = 0; start != vdict[src]; src++);\n for (dst = 0; end != vdict[dst]; dst++);\n\n buildReverseMap(src, dst);\n\n vector> result;\n vector path;\n dfs(src, dst, path, result);\n return move(result);\n }\n};\n" }, { "path": "WordSearch/WordSearch.cpp", "content": "class Solution {\npublic:\n bool exist(vector>& board, string word) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function\n \n this->word = word;\n row = board.size();\n if (row == 0) return false;\n col = board[0].size();\n \n for (int i = 0; i < row; i++) {\n for (int j = 0; j < col; j++) {\n map[i][j] = board[i][j];\n visited[i][j] = false;\n }\n }\n bool flag = false;\n for (int i = 0; i < row; i++) {\n for (int j = 0; j < col; j++) {\n if (map[i][j] == word[0]) {\n visited[i][j] = true;\n flag = DFS(i, j, 1);\n visited[i][j] = false;\n if (flag) return flag;\n }\n }\n }\n return false;\n }\n \nprivate:\n bool isValid(int x, int y) {\n if (0 <= x && x < row && 0 <= y && y < col) {\n return true;\n }\n return false;\n }\n \n bool DFS(int x, int y, int p) {\n if (p == word.size()) \n return true;\n \n bool flag = true;\n for (int i = 0; i < 4; i++) {\n int a = x + dx[i];\n int b = y + dy[i];\n if (isValid(a, b) && !visited[a][b] && map[a][b] == word[p]) {\n visited[a][b] = true;\n flag = DFS(a, b, p + 1);\n visited[a][b] = false;\n if (flag) return true;\n }\n }\n return false;\n }\n\nprivate:\n static const int MAXN = 1010;\n int dx[4] = {1, -1, 0, 0};\n int dy[4] = {0, 0, -1, 1};\n int row, col;\n // 56ms judge large\n // much faster than pass-by-reference\n char map[MAXN][MAXN];\n bool visited[MAXN][MAXN];\n string word;\n};" }, { "path": "ZigZagConversion/ZigZagConversion.cpp", "content": "class Solution {\npublic:\n string convert(string s, int nRows) {\n // Start typing your C/C++ solution below\n // DO NOT write int main() function \n \n if (nRows == 1) return s;\n string result;\n if (s.size() == 0) return result;\n\n int delta = nRows*2-2;\n for (int i = 0; i < nRows; i++) {\n for (int j = i; j < s.size(); j += delta) {\n result += s[j];\n if (i == 0 || i == nRows-1) continue;\n if (j + (nRows-i-1)*2 < s.size())\n result += s[j+(nRows-i-1)*2];\n }\n }\n return result;\n }\n};\n" } ]