├── 1-Two-Sum-map.cpp ├── 1-Two-Sum-pointer.cpp ├── 1-Two-Sum.cpp ├── 10-regular-expression-matching.cpp ├── 100-same-tree.cpp ├── 101-symmetric-tree.cpp ├── 102-binary-tree-level-order-traversal.cpp ├── 103-binary-tree-zigzag-level-order-traversal.cpp ├── 104-maximum-depth-of-binary-tree.cpp ├── 105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp ├── 106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp ├── 107-binary-tree-level-order-traversal-ii.cpp ├── 108-convert-sorted-array-to-binary-search-tree.cpp ├── 109-convert-sorted-list-to-binary-search-tree-1.cpp ├── 109-convert-sorted-list-to-binary-search-tree.cpp ├── 11-container-with-most-water.cpp ├── 110-balanced-binary-tree.cpp ├── 111-minimum-depth-of-binary-tree.cpp ├── 112-path-sum.cpp ├── 113-path-sum-ii.cpp ├── 114-flatten-binary-tree-to-linked-list.cpp ├── 115-distinct-subsequences.cpp ├── 116-populating-next-right-pointers-in-each-node.cpp ├── 117-populating-next-right-pointers-in-each-node-ii.cpp ├── 118-pascals-triangle.cpp ├── 119-pascals-triangle-ii.cpp ├── 12-integer-to-roman.cpp ├── 120-triangle.cpp ├── 121-best-time-to-buy-and-sell-stock.cpp ├── 122-best-time-to-buy-and-sell-stock-ii.cpp ├── 123-best-time-to-buy-and-sell-stock-iii.cpp ├── 124-binary-tree-maximum-path-sum.cpp ├── 125-valid-palindrome.cpp ├── 126-word-ladder-ii.cpp ├── 127-word-ladder.cpp ├── 128-longest-consecutive-sequence.cpp ├── 129-sum-root-to-leaf-numbers.cpp ├── 13-roman-to-integer.cpp ├── 130-surrounded-regions.cpp ├── 131-palindrome-partitioning.cpp ├── 132-palindrome-partitioning-ii.cpp ├── 133-clone-graph.cpp ├── 134-gas-station-1.cpp ├── 134-gas-station-2.cpp ├── 135-candy.cpp ├── 136-single-number.cpp ├── 137-single-number-ii.cpp ├── 138-copy-list-with-random-pointer.cpp ├── 139-word-break.cpp ├── 14-longest-common-prefix.cpp ├── 140-word-break-ii.cpp ├── 141-linked-list-cycle.cpp ├── 142-linked-list-cycle-ii.cpp ├── 143-reorder-list.cpp ├── 144-binary-tree-preorder-traversal.cpp ├── 145-binary-tree-postorder-traversal.cpp ├── 146-lru-cache-list.cpp ├── 147-insertion-sort-list.cpp ├── 148-sort-list.cpp ├── 149-max-points-on-a-line.cpp ├── 15-3sum.cpp ├── 150-evaluate-reverse-polish-notation.cpp ├── 151-reverse-words-in-a-string.cpp ├── 152-maximum-product-subarray.cpp ├── 153-find-minimum-in-rotated-sorted-array.cpp ├── 154-find-minimum-in-rotated-sorted-array-ii.cpp ├── 155-min-stack.cpp ├── 16-3sum-closest.cpp ├── 160-intersection-of-two-linked-lists.cpp ├── 162-find-peak-element.cpp ├── 164-maximum-gap.cpp ├── 165-compare-version-numbers.cpp ├── 166-fraction-to-recurring-decimal.cpp ├── 168-excel-sheet-column-title.cpp ├── 169-majority-element.cpp ├── 17-letter-combinations-of-a-phone-number.cpp ├── 171-excel-sheet-column-number.cpp ├── 172-factorial-trailing-zeroes.cpp ├── 173-binary-search-tree-iterator.cpp ├── 174-dungeon-game.cpp ├── 179-largest-number.cpp ├── 18-4sum.cpp ├── 187-repeated-dna-sequences.cpp ├── 188-best-time-to-buy-and-sell-stock-iv.cpp ├── 189-rotate-array.cpp ├── 19-remove-nth-node-from-end-of-list.cpp ├── 190-reverse-bits.cpp ├── 191-number-of-1-bits.cpp ├── 198-house-robber.cpp ├── 199-binary-tree-right-side-view.cpp ├── 2-Add-Two-Numbers.cpp ├── 20-valid-parentheses.cpp ├── 200-number-of-islands.cpp ├── 201-bitwise-and-of-numbers-range-1.cpp ├── 201-bitwise-and-of-numbers-range-2.cpp ├── 202-happy-number.cpp ├── 203-remove-linked-list-elements.cpp ├── 204-count-primes.cpp ├── 205-isomorphic-strings.cpp ├── 206-reverse-linked-list.cpp ├── 207-course-schedule.cpp ├── 208-implement-trie-prefix-tree.cpp ├── 209-minimum-size-subarray-sum.cpp ├── 21-merge-two-sorted-lists.cpp ├── 210-course-schedule-ii.cpp ├── 211-add-and-search-word-data-structure-design.cpp ├── 212-word-search-ii.cpp ├── 213-house-robber-ii.cpp ├── 215-kth-largest-element-in-an-array.cpp ├── 216-combination-sum-iii.cpp ├── 217-contains-duplicate.cpp ├── 218-the-skyline-problem.cpp ├── 219-contains-duplicate-ii.cpp ├── 22-generate-parentheses.cpp ├── 220-contains-duplicate-iii.cpp ├── 222-count-complete-tree-nodes.cpp ├── 223-rectangle-area.cpp ├── 224-basic-calculator.cpp ├── 225-implement-stack-using-queues.cpp ├── 226-invert-binary-tree.cpp ├── 227-basic-calculator-ii.cpp ├── 228-summary-ranges.cpp ├── 229-majority-element-ii.cpp ├── 23-merge-k-sorted-lists.cpp ├── 230-kth-smallest-element-in-a-bst.cpp ├── 231-power-of-two.cpp ├── 233-number-of-digit-one.cpp ├── 235-lowest-common-ancestor-of-a-binary-search-tree.cpp ├── 239-sliding-window-maximum.cpp ├── 24-swap-nodes-in-pairs.cpp ├── 240-search-a-2d-matrix-ii.cpp ├── 242-valid-anagram.cpp ├── 25-reverse-nodes-in-k-group.cpp ├── 257-binary-tree-paths.cpp ├── 258-add-digits.cpp ├── 26-remove-duplicates-from-sorted-array.cpp ├── 26-remove-duplicates-from-sorted-array_STL.cpp ├── 260-single-number-iii.cpp ├── 263-ugly-number.cpp ├── 264-ugly-number-ii.cpp ├── 268-missing-number.cpp ├── 27-remove-element.cpp ├── 273-integer-to-english-words.cpp ├── 274-h-index.cpp ├── 278-first-bad-version.cpp ├── 279-perfect-squares.cpp ├── 28-implement-strstr.cpp ├── 283-move-zeroes.cpp ├── 284-peeking-iterator.cpp ├── 29-divide-two-integers.cpp ├── 290-word-pattern.cpp ├── 292-nim-game.cpp ├── 3-Longest-Substring-Without-Repeating-Characters.cpp ├── 30-substring-with-concatenation-of-all-words.cpp ├── 31-next-permutation.cpp ├── 32-substring-with-concatenation-of-all-words.cpp ├── 33-search-in-rotated-sorted-array.cpp ├── 34-search-for-a-range-STL.cpp ├── 34-search-for-a-range.cpp ├── 35-search-insert-position.cpp ├── 36-valid-sudoku.cpp ├── 37-sudoku-solver.cpp ├── 38-count-and-say.cpp ├── 39-combination-sum.cpp ├── 4-median-of-two-sorted-arrays.cpp ├── 40-combination-sum-ii.cpp ├── 41-first-missing-positive.cpp ├── 42-trapping-rain-water.cpp ├── 43-multiply-strings.cpp ├── 45-jump-game-ii.cpp ├── 46-permutations.cpp ├── 47-permutations-ii.cpp ├── 48-rotate-image.cpp ├── 49-anagrams.cpp ├── 5-longest-palindromic-substring.cpp ├── 50-powx-n.cpp ├── 51-n-queens.cpp ├── 52-n-queens-ii.cpp ├── 53-maximum-subarray.cpp ├── 54-spiral-matrix.cpp ├── 55-jump-game.cpp ├── 56-merge-intervals.cpp ├── 57-insert-interval.cpp ├── 58-length-of-last-word.cpp ├── 59-spiral-matrix-ii.cpp ├── 6-zigzag-conversion.cpp ├── 60-permutation-sequence.cpp ├── 61-rotate-list.cpp ├── 62-unique-paths.cpp ├── 63-unique-paths-ii.cpp ├── 64-minimum-path-sum.cpp ├── 66-plus-one.cpp ├── 67-add-binary.cpp ├── 68-text-justification.cpp ├── 69-sqrtx.cpp ├── 7-reverse-integer.cpp ├── 70-climbing-stairs.cpp ├── 71-simplify-path.cpp ├── 72-edit-distance.cpp ├── 73-set-matrix-zeroes.cpp ├── 74-search-a-2d-matrix.cpp ├── 75-sort-colors.cpp ├── 76-minimum-window-substring.cpp ├── 77-combinations.cpp ├── 78-subsets.cpp ├── 79-word-search.cpp ├── 8-string-to-integer-atoi.cpp ├── 80-remove-duplicates-from-sorted-array-ii.cpp ├── 81-search-in-rotated-sorted-array-ii.cpp ├── 82-remove-duplicates-from-sorted-list-ii.cpp ├── 83-remove-duplicates-from-sorted-list.cpp ├── 84-largest-rectangle-in-histogram.cpp ├── 85-maximal-rectangle.cpp ├── 86-partition-list.cpp ├── 87-scramble-string.cpp ├── 88-merge-sorted-array.cpp ├── 89-gray-code.cpp ├── 9-palindrome-number.cpp ├── 90-subsets-ii.cpp ├── 91-decode-ways.cpp ├── 92-reverse-linked-list-ii.cpp ├── 93-restore-ip-addresses.cpp ├── 94-binary-tree-inorder-traversal.cpp ├── 95-unique-binary-search-trees-ii.cpp ├── 96-unique-binary-search-trees.cpp ├── 97-interleaving-string.cpp ├── 98-validate-binary-search-tree.cpp ├── 99-recover-binary-search-tree.cpp └── README.md /1-Two-Sum-map.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector twoSum(vector &numbers, int target) { 4 | vector ans; 5 | map m; 6 | for(int i=0; i::iterator it = m.find(other); 12 | if( it != m.end() && it->second != i ) { 13 | ans.push_back(i + 1); 14 | ans.push_back(it->second + 1); 15 | return ans; 16 | } 17 | } 18 | return ans; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /1-Two-Sum-pointer.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector twoSum(vector &numbers, int target) { 4 | vector ans; 5 | vector > p; 6 | int l = 0, r = numbers.size() - 1, n = numbers.size(); 7 | for (int i = 0; i < n; i++) 8 | p.push_back(make_pair(numbers[i], i + 1)); 9 | sort(p.begin(), p.end()); 10 | while (l < r) { 11 | if (p[l].first + p[r].first == target) { 12 | ans.push_back(p[l].second); 13 | ans.push_back(p[r].second); 14 | if (ans[0] > ans[1]) 15 | swap(ans[0], ans[1]); 16 | return ans; 17 | } 18 | if (p[l].first + p[r].first < target) 19 | l++; 20 | else 21 | r--; 22 | } 23 | return ans; 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /1-Two-Sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector twoSum(vector &numbers, int target) { 4 | vector ans; 5 | vector< pair > p; 6 | for(int i=0; i >::iterator it = lower_bound(p.begin() + i + 1, p.end(), make_pair(other,0)); 12 | if( it == p.end() ) 13 | continue; 14 | int pos = it - p.begin(); 15 | if( p[pos].first != other ) 16 | continue; 17 | ans.push_back(p[i].second); 18 | ans.push_back(p[pos].second); 19 | if( ans[0] > ans[1] ) 20 | swap(ans[0], ans[1]); 21 | break; 22 | } 23 | return ans; 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /10-regular-expression-matching.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isMatch(string s, string p) { 4 | int m = s.size(), n = p.size(); 5 | vector > dp(m + 1, vector(n + 1, false)); 6 | dp[0][0] = true; 7 | for (int i = 1; i <= n; i++) { 8 | dp[0][i] = (p[i - 1] == '*' && i >= 2 && dp[0][i - 2]); 9 | } 10 | for (int i = 1; i <= m; i++) { 11 | for (int k = 1; k <= n; k++) { 12 | dp[i][k] = (dp[i - 1][k - 1] && equals(s, p, i - 1, k - 1)) 13 | || ((dp[i - 1][k] || dp[i][k - 1]) && p[k - 1] == '*' 14 | && equals(s, p, i - 1, k - 2)) 15 | || (p[k - 1] == '*' && k >= 2 && dp[i][k - 2]); 16 | } 17 | } 18 | return dp[m][n]; 19 | } 20 | private : 21 | bool equals(string &s, string &p, int i, int k) { 22 | return s[i] == p[k] || p[k] == '.'; 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /100-same-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isSameTree(TreeNode *p, TreeNode *q) { 13 | if (p && !q || q && !p) 14 | return false; 15 | if (!p && !q) 16 | return true; 17 | if (p->val != q->val) 18 | return false; 19 | return isSameTree(p->left, q->left) && isSameTree(p->right, q->right); 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /101-symmetric-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isSym(TreeNode *l, TreeNode *r) { 13 | if (l == NULL || r == NULL) { 14 | return l == r; 15 | } 16 | if (l->val != r->val) { 17 | return false; 18 | } 19 | return isSym(l->right, r->left) && isSym(l->left, r->right); 20 | } 21 | bool isSymmetric(TreeNode *root) { 22 | return root == NULL ? true : isSym(root->left, root->right); 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /102-binary-tree-level-order-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector > levelOrder(TreeNode *root) { 13 | vector> ans; 14 | if (root == NULL) 15 | return ans; 16 | queue q; 17 | q.push(root); 18 | while (!q.empty()) { 19 | int len = q.size(); 20 | vector level; 21 | while (len--) { 22 | TreeNode *pre = q.front(); 23 | q.pop(); 24 | level.push_back(pre->val); 25 | if (pre->left) 26 | q.push(pre->left); 27 | if (pre->right) 28 | q.push(pre->right); 29 | } 30 | ans.push_back(level); 31 | } 32 | return ans; 33 | } 34 | }; -------------------------------------------------------------------------------- /103-binary-tree-zigzag-level-order-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector > zigzagLevelOrder(TreeNode *root) { 13 | vector > ans; 14 | bool order = false; 15 | if (root == NULL) return ans; 16 | stack pre; 17 | stack next; 18 | pre.push(root); 19 | while (!pre.empty()) { 20 | vector layer; 21 | while (!pre.empty()) { 22 | TreeNode *now = pre.top(); 23 | pre.pop(); 24 | layer.push_back(now->val); 25 | if (!order) { 26 | if (now->left) 27 | next.push(now->left); 28 | if (now->right) 29 | next.push(now->right); 30 | } else { 31 | if (now->right) 32 | next.push(now->right); 33 | if (now->left) 34 | next.push(now->left); 35 | } 36 | } 37 | order ^= true; 38 | ans.push_back(layer); 39 | swap(pre, next); 40 | } 41 | return ans; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /104-maximum-depth-of-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int maxDepth(TreeNode *root) { 13 | if (root == NULL) { 14 | return 0; 15 | } 16 | return 1 + max(maxDepth(root->left), maxDepth(root->right)); 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode *buildTree(vector &preorder, vector &inorder) { 13 | unordered_map m; 14 | for (int i = 0; i < inorder.size(); i++) 15 | m[inorder[i]] = i; 16 | return build(0, 0, inorder.size() - 1, preorder, inorder, m); 17 | } 18 | 19 | private: 20 | TreeNode *build(int x, int l, int r, vector &preorder, vector &inorder, unordered_map &m) { 21 | if (l > r) 22 | return NULL; 23 | if (l == r) 24 | return new TreeNode(inorder[l]); 25 | TreeNode *root = new TreeNode(preorder[x]); 26 | root->left = build(x + 1, l, m[preorder[x]] - 1, preorder, inorder, m); 27 | root->right = build(x + m[preorder[x]] - l + 1, m[preorder[x]] + 1, r, preorder, inorder, m); 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode *buildTree(vector &inorder, vector &postorder) { 13 | int n = inorder.size(); 14 | for (int i = 0; i < n; i++) 15 | umap[inorder[i]] = i; 16 | return build(postorder, n - 1, inorder, 0, n - 1); 17 | } 18 | 19 | private : 20 | unordered_map umap; 21 | TreeNode* build(vector &postorder, int id, vector &inorder, int l, int r) { 22 | if (id < 0 || l > r) 23 | return NULL; 24 | int pos = umap[postorder[id]]; 25 | TreeNode *root = new TreeNode(postorder[id]); 26 | root->right = build(postorder, id - 1, inorder, pos + 1, r); 27 | root->left = build(postorder, id - (r - pos) - 1, inorder, l, pos - 1); 28 | return root; 29 | } 30 | }; -------------------------------------------------------------------------------- /107-binary-tree-level-order-traversal-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector> levelOrderBottom(TreeNode *root) { 13 | vector> ans; 14 | if (root == NULL) 15 | return ans; 16 | queue q; 17 | q.push(root); 18 | while (!q.empty()) { 19 | vector layer; 20 | int len = q.size(); 21 | while (len--) { 22 | TreeNode* pre = q.front(); 23 | q.pop(); 24 | layer.push_back(pre->val); 25 | if (pre->left != NULL) 26 | q.push(pre->left); 27 | if (pre->right != NULL) 28 | q.push(pre->right); 29 | } 30 | ans.push_back(layer); 31 | } 32 | reverse(ans.begin(), ans.end()); 33 | return ans; 34 | } 35 | }; -------------------------------------------------------------------------------- /108-convert-sorted-array-to-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode *sortedArrayToBST(vector &num) { 13 | return generateBST(0, num.size() - 1, num); 14 | } 15 | 16 | private : 17 | TreeNode *generateBST(int l, int r, vector &num) { 18 | if (l > r) 19 | return NULL; 20 | int mid = (l + r) >> 1; 21 | TreeNode *root = new TreeNode(num[mid]); 22 | root->left = generateBST(l, mid - 1, num); 23 | root->right = generateBST(mid + 1, r, num); 24 | return root; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /109-convert-sorted-list-to-binary-search-tree-1.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | /** 10 | * Definition for binary tree 11 | * struct TreeNode { 12 | * int val; 13 | * TreeNode *left; 14 | * TreeNode *right; 15 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 16 | * }; 17 | */ 18 | class Solution { 19 | public: 20 | TreeNode *sortedListToBST(ListNode *head) { 21 | int cnt = 0; 22 | ListNode *p = head; 23 | while (p) { 24 | cnt++; 25 | p = p->next; 26 | } 27 | return toBST(head, cnt); 28 | 29 | } 30 | private: 31 | TreeNode *toBST(ListNode *&head, int n) { 32 | if (n == 0) 33 | return NULL; 34 | int l = (n - 1) / 2, r = n - l - 1; 35 | TreeNode *left = toBST(head, l); 36 | TreeNode *root = new TreeNode(head->val); 37 | head = head->next; 38 | root->left = left; 39 | root->right = toBST(head, r); 40 | return root; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /109-convert-sorted-list-to-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | /** 10 | * Definition for binary tree 11 | * struct TreeNode { 12 | * int val; 13 | * TreeNode *left; 14 | * TreeNode *right; 15 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 16 | * }; 17 | */ 18 | class Solution { 19 | public: 20 | TreeNode *sortedListToBST(ListNode *head) { 21 | if (head == NULL) 22 | return NULL; 23 | if (head->next == NULL) 24 | return new TreeNode(head->val); 25 | ListNode *mid = findMid(head); 26 | TreeNode *root = new TreeNode(mid->next->val); 27 | ListNode *next = mid->next->next; 28 | mid->next = NULL; 29 | root->left = sortedListToBST(head); 30 | root->right = sortedListToBST(next); 31 | return root; 32 | } 33 | private: 34 | ListNode* findMid(ListNode* head) { 35 | ListNode *first = head, *second = head->next; 36 | while (second) { 37 | second = second->next; 38 | if (second == NULL || second->next == NULL) 39 | break; 40 | second = second->next; 41 | first = first->next; 42 | } 43 | return first; 44 | } 45 | }; 46 | -------------------------------------------------------------------------------- /11-container-with-most-water.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxArea(vector &height) { 4 | int ans = 0, l = 0, r = height.size() - 1; 5 | while (l < r) { 6 | ans = max(ans, (r - l) * min(height[r], height[l])); 7 | int t = r; 8 | if (height[r] <= height[l]) 9 | r--; 10 | if (height[l] <= height[t]) 11 | l++; 12 | } 13 | return ans; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /110-balanced-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isBalanced(TreeNode *root) { 13 | int deep = 0; 14 | return isBal(root, deep); 15 | } 16 | 17 | private: 18 | bool isBal(TreeNode *root, int &deep) { 19 | if (root == NULL) { 20 | deep = 0; 21 | return true; 22 | } 23 | 24 | int ld = 0, rd = 0; 25 | if (!isBal(root->left, ld) || !isBal(root->right, rd) || abs(rd - ld) > 1) 26 | return false; 27 | 28 | deep += max(ld, rd) + 1; 29 | return true; 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /111-minimum-depth-of-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int minDepth(TreeNode *root) { 13 | if (root == NULL) 14 | return 0; 15 | findMinDepth(root, 1); 16 | return min_depth; 17 | } 18 | 19 | private : 20 | int min_depth = INT_MAX; 21 | void findMinDepth(TreeNode *root, int depth) { 22 | if (root == NULL || depth >= min_depth) 23 | return ; 24 | if (root->left == NULL && root->right == NULL) { 25 | min_depth = min(min_depth, depth); 26 | return ; 27 | } 28 | findMinDepth(root->left, depth + 1); 29 | findMinDepth(root->right, depth + 1); 30 | } 31 | }; -------------------------------------------------------------------------------- /112-path-sum.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool hasPathSum(TreeNode *root, int sum) { 13 | if (root == NULL) 14 | return false; 15 | if (root->left == NULL && root->right == NULL) 16 | return (sum - root->val) == 0; 17 | if (hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val)) 18 | return true; 19 | return false; 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /113-path-sum-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector > pathSum(TreeNode *root, int sum) { 13 | findPath(root, sum); 14 | return ans; 15 | } 16 | 17 | private: 18 | vector > ans; 19 | vector now; 20 | void findPath(TreeNode *root, int sum) { 21 | if (root == NULL) 22 | return ; 23 | now.push_back(root->val); 24 | if (root->left == NULL && root->right == NULL) { 25 | if (sum - root->val == 0) 26 | ans.push_back(now); 27 | } else { 28 | findPath(root->left, sum - root->val); 29 | findPath(root->right, sum - root->val); 30 | } 31 | now.pop_back(); 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /114-flatten-binary-tree-to-linked-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void flatten(TreeNode *root) { 13 | tail = root; 14 | travel(root); 15 | } 16 | 17 | private: 18 | TreeNode *tail = NULL; 19 | void travel(TreeNode *root) { 20 | if (root == NULL) 21 | return ; 22 | if (root != tail) { 23 | tail->right = root; 24 | tail->left = NULL; 25 | tail = tail->right; 26 | } 27 | TreeNode* right = root->right; 28 | travel(root->left); 29 | travel(right); 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /115-distinct-subsequences.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numDistinct(string S, string T) { 4 | if (S.size() == 0) 5 | return 0; 6 | vector > dp(2, vector(S.size(), 0)); 7 | dp[0][0] = (S[0] == T[0] ? 1 : 0); 8 | for (int i = 1; i < S.size(); i++) { 9 | dp[0][i] = (S[i] == T[0] ? dp[0][i - 1] + 1 : dp[0][i - 1]); 10 | } 11 | int id = 0; 12 | for (int i = 1; i < T.size(); i++) { 13 | id ^= 1; 14 | dp[id][i - 1] = 0; 15 | for (int k = i; k < S.size(); k++) { 16 | dp[id][k] = dp[id][k - 1] + (S[k] == T[i] ? dp[id ^ 1][k - 1] : 0); 17 | } 18 | } 19 | return dp[id].back(); 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /116-populating-next-right-pointers-in-each-node.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree with next pointer. 3 | * struct TreeLinkNode { 4 | * int val; 5 | * TreeLinkNode *left, *right, *next; 6 | * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | void connect(TreeLinkNode *root) { 12 | if (root == NULL || root->left == NULL && root->right == NULL) 13 | return ; 14 | root->left->next = root->right; 15 | root->right->next = root->next == NULL ? NULL : root->next->left; 16 | 17 | connect(root->left); 18 | connect(root->right); 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /117-populating-next-right-pointers-in-each-node-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree with next pointer. 3 | * struct TreeLinkNode { 4 | * int val; 5 | * TreeLinkNode *left, *right, *next; 6 | * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | void connect(TreeLinkNode *root) { 12 | if (root == NULL || root->left == NULL && root->right == NULL) 13 | return ; 14 | if (root->left && root->right) { 15 | root->left->next = root->right; 16 | } 17 | TreeLinkNode *right = root->right; 18 | if (right == NULL) 19 | right = root->left; 20 | for (TreeLinkNode *p = root->next; p; p = p->next) { 21 | if (p->left) { 22 | right->next = p->left; 23 | break; 24 | } 25 | if (p->right) { 26 | right->next = p->right; 27 | break; 28 | } 29 | } 30 | connect(root->right); 31 | connect(root->left); 32 | } 33 | }; -------------------------------------------------------------------------------- /118-pascals-triangle.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > generate(int numRows) { 4 | vector > ans; 5 | if (numRows == 0) 6 | return ans; 7 | ans.push_back(vector(1, 1)); 8 | for (int i = 1; i < numRows; i++) { 9 | vector tmp; 10 | tmp.push_back(1); 11 | for (int k = 1; k < i; k++) { 12 | tmp.push_back(ans[i - 1][k - 1] + ans[i - 1][k]); 13 | } 14 | tmp.push_back(1); 15 | ans.push_back(tmp); 16 | } 17 | return ans; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /119-pascals-triangle-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector getRow(int rowIndex) { 4 | vector ans; 5 | if (rowIndex < 0) 6 | return ans; 7 | for (int i = 0; i <= rowIndex; i++) { 8 | for (int k = ans.size() - 1; k >= 1; k--) 9 | ans[k] += ans[k - 1]; 10 | ans.push_back(1); 11 | } 12 | return ans; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /12-integer-to-roman.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string intToRoman(int num) { 4 | string symbol[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}; 5 | int value[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; 6 | string ans; 7 | int p = 0; 8 | while (num) { 9 | while (num >= value[p]) { 10 | num -= value[p]; 11 | ans += symbol[p]; 12 | } 13 | p++; 14 | } 15 | return ans; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /120-triangle.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minimumTotal(vector > &triangle) { 4 | int n = triangle.size(); 5 | vector dp = triangle[n - 1]; 6 | for (int i = n - 2; i >= 0; i--) { 7 | for (int k = 0; k <= i; k++) { 8 | dp[k] = triangle[i][k] + min(dp[k], dp[k + 1]); 9 | } 10 | } 11 | return dp[0]; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /121-best-time-to-buy-and-sell-stock.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector &prices) { 4 | int n = prices.size(); 5 | if (n == 0) 6 | return 0; 7 | int lmin = prices[0], ans = 0; 8 | for (int i = 1; i < n; i++) { 9 | ans = max(ans, prices[i] - lmin); 10 | lmin = min(lmin, prices[i]); 11 | } 12 | return ans; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /122-best-time-to-buy-and-sell-stock-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector &prices) { 4 | int profit = 0; 5 | for (int i = 1; i < prices.size(); i++) 6 | profit += max(prices[i] - prices[i - 1], 0); 7 | return profit; 8 | } 9 | }; 10 | -------------------------------------------------------------------------------- /123-best-time-to-buy-and-sell-stock-iii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector &prices) { 4 | int n = prices.size(); 5 | if (n <= 1) 6 | return 0; 7 | int profit = 0; 8 | int r = prices[n - 1]; 9 | vector rmax(n, 0); 10 | int l = prices[0]; 11 | vector lmax(n, 0); 12 | for (int i = n - 1; i >= 0; i--) { 13 | r = prices[i] > r ? prices[i] : r; 14 | rmax[i] = r - prices[i]; 15 | } 16 | 17 | for (int i = 0; i < n; i++) { 18 | l = prices[i] < l ? prices[i] : l; 19 | lmax[i] = prices[i] - l; 20 | } 21 | 22 | vector ans(n, 0); 23 | for (int i = n - 2; i >= 0; i--) { 24 | ans[i] = max(rmax[i], ans[i + 1]); 25 | } 26 | 27 | for (int i = 0; i < n - 1; i++) { 28 | profit = max(lmax[i] + ans[i], profit); 29 | } 30 | return profit; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /124-binary-tree-maximum-path-sum.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int ans = INT_MIN; 13 | int Travel(TreeNode *root) { 14 | if (root == NULL) 15 | return INT_MIN; 16 | int l = Travel(root->left); 17 | int r = Travel(root->right); 18 | int acc; 19 | if (l == r && l == INT_MIN) { 20 | ans = max(ans, root->val); 21 | return root->val; 22 | } else { 23 | if (l == INT_MIN || r == INT_MIN) { 24 | acc = max(root->val, max(l, r) + root->val); 25 | } else { 26 | acc = max(l + root->val, max(r + root->val, root->val)); 27 | } 28 | } 29 | int tmp = max(acc, max(l, r)); 30 | if (l != INT_MIN && r != INT_MIN) 31 | tmp = max(tmp, l + r + root->val); 32 | ans = max(tmp, ans); 33 | return acc; 34 | } 35 | int maxPathSum(TreeNode *root) { 36 | Travel(root); 37 | return ans; 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /125-valid-palindrome.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPalindrome(string& s) { 4 | int l = 0, r = s.size() - 1; 5 | while (l < r) { 6 | while (l < r && !isalpha(s[l]) && !isdigit(s[l])) 7 | l++; 8 | while (l < r && !isalpha(s[r]) && !isdigit(s[r])) 9 | r--; 10 | if (tolower(s[l]) != tolower(s[r])) 11 | return false; 12 | ++l; 13 | --r; 14 | } 15 | return true; 16 | } 17 | }; -------------------------------------------------------------------------------- /126-word-ladder-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > findLadders(string start, string end, unordered_set &dict) { 4 | vector> ans; 5 | if(start == end) 6 | return ans; 7 | dict.insert(start); 8 | dict.insert(end); 9 | int n = dict.size(); 10 | vector stoe(n, INT_MAX); 11 | vector etos(n, INT_MAX); 12 | vector vd; 13 | unordered_map umap; 14 | int cnt = 0; 15 | for (auto &i : dict) { 16 | vd.push_back(i); 17 | umap[i] = cnt++; 18 | } 19 | int min_len = SPFA(start, end, umap, stoe); 20 | if (min_len == INT_MAX) 21 | return ans; 22 | SPFA(end, start, umap, etos); 23 | vector > vset(min_len + 1); 24 | 25 | for (int i = 0; i < n; i++) { 26 | if (stoe[i] != INT_MAX && etos[i] != INT_MAX && stoe[i] + etos[i] == min_len) { 27 | vset[stoe[i]].insert(vd[i]); 28 | } 29 | } 30 | ans.push_back(vector{start}); 31 | vector> next; 32 | 33 | for (int i = 1; i <= min_len; i++) { 34 | next.clear(); 35 | for (int k = 0; k < ans.size(); k++) { 36 | string node = ans[k].back(); 37 | vector t = ans[k]; 38 | for (int c = 0; c < node.size(); c++) { 39 | char ch = node[c]; 40 | for (int j = 0; j < 26; j++) { 41 | if (ch != 'a' + j) { 42 | node[c] = 'a' + j; 43 | if (vset[i].count(node)) { 44 | t.push_back(node); 45 | next.push_back(t); 46 | t.pop_back(); 47 | } 48 | } 49 | } 50 | node[c] = ch; 51 | } 52 | } 53 | ans = next; 54 | } 55 | return ans; 56 | } 57 | 58 | private: 59 | int SPFA(string start, string end, unordered_map dict, vector& dist) { 60 | int n = dict.size(); 61 | if (start == end) 62 | return 0; 63 | queue q; 64 | unordered_set used; 65 | 66 | used.insert(start); 67 | dist[dict[start]] = 0; 68 | q.push(start); 69 | 70 | int min_len = INT_MAX; 71 | while (!q.empty()) { 72 | string now = q.front(); 73 | q.pop(); 74 | used.erase(now); 75 | int x = dict[now]; 76 | for (int i = 0; i < now.size(); i++) { 77 | for (int k = 0; k < 26; k++) { 78 | string t = now; 79 | if (t[i] == 'a' + k) 80 | continue; 81 | t[i] = 'a' + k; 82 | if (dict.count(t)) { 83 | int to = dict[t]; 84 | if (dist[to] > dist[x] + 1) { 85 | dist[to] = dist[x] + 1; 86 | if (used.count(t) == 0) { 87 | q.push(t); 88 | used.insert(t); 89 | } 90 | } 91 | } 92 | } 93 | } 94 | } 95 | return dist[dict[end]]; 96 | } 97 | }; 98 | -------------------------------------------------------------------------------- /127-word-ladder.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int ladderLength(string start, string end, unordered_set &dict) { 4 | int n = dict.size(); 5 | if (start == end) 6 | return 0; 7 | queue > q; 8 | if (dict.count(start)) 9 | dict.erase(start); 10 | q.push(make_pair(start, 1)); 11 | while (!q.empty()) { 12 | pair now = q.front(); 13 | q.pop(); 14 | for (int i = 0; i < now.first.size(); i++) { 15 | for (int k = 0; k < 26; k++) { 16 | char t = now.first[i]; 17 | if (now.first[i] == 'a' + k) 18 | continue; 19 | now.first[i] = 'a' + k; 20 | if (now.first == end) 21 | return now.second + 1; 22 | if (dict.count(now.first)) { 23 | q.push(make_pair(now.first, now.second + 1)); 24 | dict.erase(now.first); 25 | } 26 | now.first[i] = t; 27 | } 28 | } 29 | } 30 | return 0; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /128-longest-consecutive-sequence.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int longestConsecutive(vector &num) { 4 | unordered_set s; 5 | int ans = 0; 6 | for (int i = 0; i < num.size(); i++) 7 | s.insert(num[i]); 8 | for (int i = 0; i < num.size(); i++) { 9 | if (s.empty()) 10 | break; 11 | if (s.count(num[i])) { 12 | int t = num[i] + 1, cnt = 1; 13 | s.erase(num[i]); 14 | while (s.count(t)) { 15 | s.erase(t); 16 | t++; 17 | cnt++; 18 | } 19 | t = num[i] - 1; 20 | while (s.count(t)) { 21 | s.erase(t); 22 | t--; 23 | cnt++; 24 | } 25 | ans = max(ans, cnt); 26 | } 27 | } 28 | return ans; 29 | } 30 | 31 | }; 32 | -------------------------------------------------------------------------------- /129-sum-root-to-leaf-numbers.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int sumNumbers(TreeNode *root) { 13 | int num = 0; 14 | return travel(root, num); 15 | } 16 | 17 | private: 18 | int ans = 0; 19 | int travel(TreeNode *root, int num) { 20 | if (root == NULL) 21 | return 0; 22 | if (root->left == NULL && root->right == NULL) { 23 | return num * 10 + root->val; 24 | } 25 | int val = root->val; 26 | return travel(root->left, num * 10 + val) + travel(root->right, num * 10 + val); 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /13-roman-to-integer.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int romanToInt(string s) { 4 | int ans = 0; 5 | for (int i = 0; i < s.size(); i++) { 6 | int v = find(s[i]); 7 | if (i + 1 < s.size() && v < find(s[i + 1])) { 8 | ans -= v; 9 | } else { 10 | ans += v; 11 | } 12 | } 13 | return ans; 14 | } 15 | private : 16 | int find(char c) { 17 | switch (c) { 18 | case 'I': return 1; 19 | case 'V': return 5; 20 | case 'X': return 10; 21 | case 'L': return 50; 22 | case 'C': return 100; 23 | case 'D': return 500; 24 | case 'M': return 1000; 25 | default: return 0; 26 | } 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /130-surrounded-regions.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void solve(vector> &board) { 4 | n = board.size(); 5 | if (n == 0) 6 | return ; 7 | m = board[0].size(); 8 | if (m == 0) 9 | return ; 10 | for (int i = 0; i < n; i++) { 11 | if (board[i][0] == 'O') 12 | dfs(i, 0, board); 13 | if (board[i][m - 1] == 'O') 14 | dfs(i, m - 1, board); 15 | } 16 | for (int i = 0; i < m; i++) { 17 | if (board[0][i] == 'O') 18 | dfs(0, i, board); 19 | if (board[n - 1][i] == 'O') 20 | dfs(n - 1, i, board); 21 | } 22 | for (int i = 0; i < n; i++) { 23 | for (int k = 0; k < m; k++) { 24 | board[i][k] = (board[i][k] == 'O' ? 'X' : board[i][k]); 25 | board[i][k] = (board[i][k] == 'A' ? 'O' : board[i][k]); 26 | } 27 | } 28 | } 29 | 30 | private: 31 | int n, m; 32 | vector dx{0, 1, -1, 0}; 33 | vector dy{1, 0, 0, -1}; 34 | stack > stk; 35 | bool dfs(int x, int y, vector> &board) { 36 | stk.push(make_pair(x, y)); 37 | board[x][y] = 'A'; 38 | while (!stk.empty()) { 39 | pair now = stk.top(); 40 | stk.pop(); 41 | for (int i = 0; i < 4; i++) { 42 | int xx = now.first + dx[i]; 43 | int yy = now.second + dy[i]; 44 | if (xx >= 0 && xx < n && yy >= 0 && yy < m && board[xx][yy] == 'O') { 45 | board[xx][yy] = 'A'; 46 | stk.push(make_pair(xx, yy)); 47 | } 48 | } 49 | } 50 | } 51 | }; 52 | -------------------------------------------------------------------------------- /131-palindrome-partitioning.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > partition(string s) { 4 | vector > vec, ans; 5 | int len = s.size(); 6 | for (int i = 0; i < len; i++) { 7 | vector v; 8 | for (int k = i; k < len; k++) { 9 | string sub = s.substr(i, k - i + 1); 10 | if (ispalindrome(sub)) 11 | v.push_back(sub); 12 | } 13 | vec.push_back(v); 14 | } 15 | vector v; 16 | dfs(0, s, vec, v, ans); 17 | return ans; 18 | } 19 | 20 | private : 21 | void dfs(int x, string s, vector > &vec, vector &v, vector > &ans) { 22 | if (x == s.size()) { 23 | ans.push_back(v); 24 | return ; 25 | } 26 | string t = ""; 27 | for (int i = 0; i < vec[x].size(); i++) { 28 | v.push_back(vec[x][i]); 29 | dfs(x + vec[x][i].size(), s, vec, v, ans); 30 | v.pop_back(); 31 | } 32 | } 33 | bool ispalindrome(string s) { 34 | int len = s.size(); 35 | for (int i = 0; i < s.size() / 2; i++) { 36 | if (s[i] != s[len - i - 1]) 37 | return false; 38 | } 39 | return true; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /132-palindrome-partitioning-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minCut(string s) { 4 | int n = s.size(); 5 | vector cut(n + 1, 0); // number of cuts for the first k characters 6 | for (int i = 0; i <= n; i++) 7 | cut[i] = i - 1; 8 | for (int i = 0; i < n; i++) { 9 | for (int j = 0; i - j >= 0 && i + j < n && s[i - j] == s[i + j] ; j++) // odd length palindrome 10 | cut[i + j + 1] = min(cut[i + j + 1],1 + cut[i - j]); 11 | 12 | for (int j = 1; i - j + 1 >= 0 && i + j < n && s[i - j + 1] == s[i + j]; j++) // even length palindrome 13 | cut[i + j + 1] = min(cut[i + j + 1],1+cut[i - j + 1]); 14 | } 15 | return cut[n]; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /133-clone-graph.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for undirected graph. 3 | * struct UndirectedGraphNode { 4 | * int label; 5 | * vector neighbors; 6 | * UndirectedGraphNode(int x) : label(x) {}; 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) { 12 | if (node == NULL) 13 | return NULL; 14 | unordered_map mp; 15 | dfs(node, mp); 16 | return mp[node->label]; 17 | } 18 | 19 | private : 20 | void dfs(UndirectedGraphNode *node, unordered_map &mp) { 21 | int label = node->label; 22 | UndirectedGraphNode *now = mp.count(label) == 0 ? new UndirectedGraphNode(label) : mp[label]; 23 | mp[label] = now; 24 | for (int i = 0; i < node->neighbors.size(); i++) { 25 | int to_label = node->neighbors[i]->label; 26 | UndirectedGraphNode* to = mp.count(to_label) == 0 ? new UndirectedGraphNode(to_label) : mp[to_label]; 27 | now->neighbors.push_back(to); 28 | if (mp.count(to_label)) { 29 | mp[to_label] = to; 30 | continue; 31 | } 32 | mp[to_label] = to; 33 | dfs(node->neighbors[i], mp); 34 | } 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /134-gas-station-1.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int canCompleteCircuit(vector &gas, vector &cost) { 4 | int s = 0; 5 | for (int i = 0; i < gas.size(); i++) 6 | s += gas[i] - cost[i]; 7 | if (s < 0) 8 | return -1; 9 | vector g(gas.size(), 0); 10 | for (int i = 0; i < gas.size(); i++) 11 | g[i] = gas[i] - cost[i]; 12 | for (int i = 0; i < gas.size(); i++) 13 | g[i + gas.size()] = g[i]; 14 | int pos = 0, maxsum = -1, p = -1, sum = 0; 15 | for (int i = 0; i < g.size(); i++) { 16 | if (sum + g[i] < 0) { 17 | sum = 0; 18 | p = i; 19 | continue; 20 | } 21 | sum += g[i]; 22 | if (sum > maxsum) { 23 | maxsum = sum; 24 | pos = p; 25 | } 26 | } 27 | if (maxsum < 0) 28 | return -1; 29 | return (pos + 1) % gas.size(); 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /134-gas-station-2.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int canCompleteCircuit(vector &gas, vector &cost) { 4 | int sum = 0, total = 0, start = 0; 5 | for(int i = 0; i < gas.size(); ++i) { 6 | sum += gas[i] - cost[i]; 7 | total += gas[i] - cost[i]; 8 | if (sum < 0) { 9 | start = i + 1; 10 | sum = 0; 11 | } 12 | } 13 | return total >= 0 ? start : -1; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /135-candy.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int candy(vector &ratings) { 4 | int sum = 1, pos = 0, num = 1; 5 | int n = ratings.size(); 6 | if (n == 0) 7 | return 0; 8 | for (int i = 1; i < n; i++) { 9 | if (ratings[i] > ratings[i - 1]) { 10 | num++; 11 | sum += num; 12 | } else if (ratings[i] == ratings[i - 1]) { 13 | num = 1; 14 | sum += num; 15 | } else { 16 | int t = 0; 17 | while (i < n && ratings[i] < ratings[i - 1]) { 18 | sum += ++t; 19 | i++; 20 | } 21 | if (num <= t) 22 | sum += (t + 1 - num); 23 | num = 1; 24 | i--; 25 | } 26 | } 27 | return sum; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /136-single-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int singleNumber(int A[], int n) { 4 | for (int i = 1; i < n; i++) 5 | A[i] ^= A[i-1]; 6 | return A[n-1]; 7 | } 8 | }; 9 | -------------------------------------------------------------------------------- /137-single-number-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int singleNumber(int A[], int n) { 4 | int one = 0, two = 0, three = 0; 5 | for (int i = 0; i < n; i++) { 6 | two |= (one & A[i]); 7 | one ^= A[i]; 8 | three = ~(one & two); 9 | two &= three; 10 | one &= three; 11 | } 12 | return one; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /138-copy-list-with-random-pointer.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | RandomListNode *copyRandomList(RandomListNode *head) { 4 | if (head == NULL) 5 | return NULL; 6 | RandomListNode *cp = NULL; 7 | RandomListNode *p = head; 8 | for (p = head; p;) { 9 | RandomListNode *t = new RandomListNode(p->label); 10 | t->next = p->next; 11 | p->next = t; 12 | p = p->next->next; 13 | } 14 | cp = head->next; 15 | for (p = head; p;) { 16 | p->next->random = p->random ? p->random->next : NULL; 17 | p = p->next->next; 18 | } 19 | for (p = head; p; p = p->next) { 20 | RandomListNode *t = p->next; 21 | p->next = p->next->next; 22 | t->next = p->next == NULL ? NULL : p->next->next; 23 | } 24 | return cp; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /139-word-break.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool wordBreak(string s, unordered_set &dict) { 4 | int n = s.size(); 5 | vector dp(n, 0); 6 | for (int i = 0; i < n; i++) { 7 | if (!(i != 0 && dp[i - 1] == true || i == 0)) 8 | continue; 9 | for (auto k = dict.begin(); k != dict.end(); k++) { 10 | int len = string(*k).size(); 11 | if (i + len > n || dp[i + len - 1]) { 12 | continue; 13 | } 14 | dp[i + len - 1] = dict.count(s.substr(i, len)); 15 | } 16 | } 17 | return dp[n - 1]; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /14-longest-common-prefix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string longestCommonPrefix(vector &strs) { 4 | if (strs.size() == 0) 5 | return ""; 6 | for (int i = 0; i < strs[0].size(); i++) { 7 | for (int k = 1; k < strs.size(); k++) { 8 | if (strs[k].size() < i || strs[k][i] != strs[0][i]) 9 | return strs[0].substr(0, i); 10 | } 11 | } 12 | return strs[0]; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /140-word-break-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector ans; 4 | string ss; 5 | void findPath(int id, string p, vector< vector > &path, vector &pre) { 6 | if (id < 0) { 7 | ans.push_back(p); 8 | return ; 9 | } 10 | string tmp = (p == "" ? p : ' ' + p); 11 | int pid = pre[id]; 12 | for (int i = 0; i < path[pid].size(); i++) { 13 | findPath(id - path[pid][i], ss.substr(id - path[pid][i] + 1, path[pid][i]) + tmp, path, pre); 14 | } 15 | } 16 | vector wordBreak(string s, unordered_set &dict) { 17 | int n = s.size(); 18 | ss = s; 19 | vector< vector > path; 20 | vector pre(n, -1); 21 | vector dp(n, 0); 22 | for (int i = 0; i < n; i++) { 23 | if (i != 0 && !dp[i - 1]) 24 | continue; 25 | for (auto k = dict.begin(); k != dict.end(); k++) { 26 | int len = string(*k).size(); 27 | bool f = (*k == s.substr(i, len)); 28 | if (i + len <= n && f) { 29 | if (pre[i + len - 1] == -1) { 30 | pre[i + len - 1] = path.size(); 31 | vector t; 32 | t.push_back(len); 33 | path.push_back(t); 34 | } else { 35 | path[pre[i + len - 1]].push_back(len); 36 | } 37 | } 38 | if (i + len > n || dp[i + len - 1]) { 39 | continue; 40 | } 41 | dp[i + len - 1] = f; 42 | } 43 | } 44 | 45 | if (!dp[n - 1]) 46 | return ans; 47 | findPath(n - 1, "", path, pre); 48 | return ans; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /141-linked-list-cycle.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | bool hasCycle(ListNode *head) { 12 | if (head == NULL) 13 | return false; 14 | 15 | ListNode *p1 = head, *p2 = head; 16 | while (p2 && p2->next) { 17 | p1 = p1->next; 18 | p2 = p2->next->next; 19 | if (p1 == p2) 20 | return true; 21 | } 22 | return false; 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /142-linked-list-cycle-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *detectCycle(ListNode *head) { 12 | ListNode *fast = head, *slow = head; 13 | while (slow && slow->next) { 14 | fast = fast->next; 15 | slow = slow->next->next; 16 | if (slow == fast) { 17 | fast = head; 18 | while (slow != fast) { 19 | slow = slow->next; 20 | fast = fast->next; 21 | } 22 | return slow; 23 | } 24 | } 25 | return NULL; 26 | } 27 | }; -------------------------------------------------------------------------------- /143-reorder-list.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | /** 4 | * @param head: The first node of linked list. 5 | * @return: void 6 | */ 7 | void reorderList(ListNode *head) { 8 | if (head == NULL || head->next == NULL) 9 | return ; 10 | ListNode *slow = head, *fast = head; 11 | while (fast->next && fast->next->next) { 12 | slow = slow->next; 13 | fast = fast->next->next; 14 | } 15 | ListNode *t = slow->next; 16 | ListNode *right = NULL; 17 | while (t) { 18 | ListNode *p = t->next; 19 | t->next = right; 20 | right = t; 21 | t = p; 22 | } 23 | slow->next = NULL; 24 | t = head; 25 | while (right) { 26 | ListNode *p = t->next; 27 | t->next = right; 28 | right = right->next; 29 | t->next->next = p; 30 | t = t->next->next; 31 | } 32 | } 33 | }; 34 | 35 | -------------------------------------------------------------------------------- /144-binary-tree-preorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector preorderTraversal(TreeNode* root) { 13 | vector ans; 14 | if (root == NULL) 15 | return ans; 16 | stack stk; 17 | stk.push(root); 18 | while (!stk.empty()) { 19 | TreeNode* now = stk.top(); 20 | stk.pop(); 21 | ans.push_back(now->val); 22 | if (now->right) 23 | stk.push(now->right); 24 | if (now->left) 25 | stk.push(now->left); 26 | } 27 | return ans; 28 | } 29 | }; -------------------------------------------------------------------------------- /145-binary-tree-postorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector postorderTraversal(TreeNode* root) { 13 | vector ans; 14 | if (root == NULL) 15 | return ans; 16 | stack stk; 17 | stk.push(root); 18 | while (!stk.empty()) { 19 | TreeNode *now = stk.top(); 20 | stk.pop(); 21 | ans.push_back(now->val); 22 | if (now->left) 23 | stk.push(now->left); 24 | if (now->right) 25 | stk.push(now->right); 26 | } 27 | reverse(ans.begin(), ans.end()); 28 | return ans; 29 | } 30 | }; -------------------------------------------------------------------------------- /146-lru-cache-list.cpp: -------------------------------------------------------------------------------- 1 | struct Node { 2 | int val; 3 | Node *next; 4 | Node(int key, int x) : key(key), val(x), next(NULL) {} 5 | int key; 6 | }; 7 | 8 | class LRUCache{ 9 | public: 10 | LRUCache(int capacity) { 11 | head = new Node(-1, -1); 12 | tail = head; 13 | cap = capacity; 14 | cnt = 0; 15 | } 16 | 17 | int get(int key) { 18 | if (m.count(key) == 0) 19 | return -1; 20 | set(key, m[key]->next->val); 21 | return m[key]->next->val; 22 | } 23 | 24 | void set(int key, int value) { 25 | if (m.count(key) == 0) { 26 | if (cap == m.size()) { 27 | m.erase(head->next->key); 28 | if (head->next == tail) 29 | tail = head; 30 | head->next = head->next->next; 31 | if (head->next) { 32 | m[head->next->key] = head; 33 | } 34 | } 35 | tail->next = new Node(key, value); 36 | m[key] = tail; 37 | tail = tail->next; 38 | } else { 39 | if (tail == m[key]->next) { 40 | tail->val = value; 41 | return ; 42 | } 43 | Node* pre = m[key]; 44 | Node* now = pre->next; 45 | pre->next = now->next; 46 | if (now->next) { 47 | m[now->next->key] = pre; 48 | } 49 | tail->next = now; 50 | now->next = NULL; 51 | m[key] = tail; 52 | now->val = value; 53 | tail = now; 54 | } 55 | } 56 | 57 | private: 58 | int cap, cnt; 59 | map m; 60 | Node *head; 61 | Node *tail; 62 | }; 63 | -------------------------------------------------------------------------------- /147-insertion-sort-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *insertionSortList(ListNode *head) { 12 | ListNode ans = ListNode(0); 13 | 14 | while (head) { 15 | ListNode *p = &ans; 16 | while (p->next != NULL && p->next->val < head->val) { 17 | p = p->next; 18 | } 19 | ListNode *t = head->next; 20 | head->next = p->next; 21 | p->next = head; 22 | head = t; 23 | } 24 | return ans.next; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /148-sort-list.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | ListNode *sortList(ListNode *head) { 4 | int len = calculateLength(head); 5 | return mergeSort(head, len); 6 | } 7 | 8 | private : 9 | ListNode *mergeSort(ListNode *&head, int len) { 10 | if (len == 0) 11 | return NULL; 12 | if (len == 1) { 13 | ListNode *ans = head; 14 | head = head->next; 15 | ans->next = NULL; 16 | return ans; 17 | } 18 | ListNode *left = mergeSort(head, len / 2); 19 | ListNode *right = mergeSort(head, len - len / 2); 20 | return merge(left, right); 21 | } 22 | ListNode *merge(ListNode *left, ListNode *right) { 23 | ListNode *head = new ListNode(0); 24 | int i = 0, k = 0; 25 | ListNode *p = head; 26 | for (;left || right; p = p->next) { 27 | if (left == NULL || right && right->val < left->val) { 28 | p->next = right; 29 | right = right->next; 30 | } else { 31 | p->next = left; 32 | left = left->next; 33 | } 34 | } 35 | p->next = NULL; 36 | return head->next; 37 | } 38 | int calculateLength(ListNode *head) { 39 | int len = 0; 40 | while (head) { 41 | len++; 42 | head = head->next; 43 | } 44 | return len; 45 | } 46 | }; 47 | 48 | -------------------------------------------------------------------------------- /149-max-points-on-a-line.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a point. 3 | * struct Point { 4 | * int x; 5 | * int y; 6 | * Point() : x(0), y(0) {} 7 | * Point(int a, int b) : x(a), y(b) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int maxPoints(vector &points) { 13 | if (points.size() == 0) 14 | return 0; 15 | int ans = 0; 16 | for (int i = 0; i < points.size(); i++) { 17 | unordered_map map; 18 | int same = 0, straight = 0; 19 | for (int k = 0; k < points.size(); k++) { 20 | if (points[i].y == points[k].y && points[i].x == points[k].x) { 21 | same++; 22 | continue; 23 | } 24 | if (points[i].x == points[k].x) { 25 | straight++; 26 | continue; 27 | } 28 | double v = (points[i].y - points[k].y) * 1.0 / (points[i].x - points[k].x); 29 | map[v]++; 30 | } 31 | ans = max(ans, straight + same); 32 | for (auto &ele : map) 33 | ans = max(ans, ele.second + same); 34 | } 35 | return ans; 36 | } 37 | }; -------------------------------------------------------------------------------- /15-3sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > threeSum(vector &num) { 4 | int n = num.size(); 5 | sort(num.begin(), num.end()); 6 | vector > ans; 7 | for (int i = 0; i < n - 1; i++) { 8 | if (i != 0) { 9 | while(i < n && num[i] == num[i - 1]) 10 | i++; 11 | } 12 | int k = i + 1, p = n - 1; 13 | while (k < p) { 14 | if (num[k] + num[p] == -num[i]) { 15 | ans.push_back({num[i], num[k], num[p]}); 16 | while (k + 1 < p && num[k + 1] == num[k]) 17 | k++; 18 | int t = num[p]; 19 | while (t == num[p] && k < p) 20 | p--; 21 | continue; 22 | } 23 | if (num[k] + num[p] > -num[i]) { 24 | p--; 25 | } else { 26 | k++; 27 | } 28 | } 29 | } 30 | return ans; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /150-evaluate-reverse-polish-notation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int evalRPN(vector &tokens) { 4 | stack stk; 5 | for (int i = 0; i < tokens.size(); i++) { 6 | if (tokens[i].size() > 1 || isdigit(tokens[i][0])) { 7 | stk.push(atoi(tokens[i].c_str())); 8 | } else { 9 | int b = stk.top(); stk.pop(); 10 | int a = stk.top(); stk.pop(); 11 | int now = 0; 12 | switch(tokens[i][0]) { 13 | case '+' : now = a + b; break; 14 | case '-' : now = a - b; break; 15 | case '*' : now = a * b; break; 16 | case '/' : now = a / b; break; 17 | } 18 | stk.push(now); 19 | } 20 | } 21 | return stk.top(); 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /151-reverse-words-in-a-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void reverseWords(string &s) { 4 | string ans = ""; 5 | for (int i = 0; i < s.size(); i++) { 6 | if (s[i] != ' ') { 7 | string t = ""; 8 | while (i < s.size() && s[i] != ' ') 9 | t += s[i++]; 10 | ans = t + ' ' + ans; 11 | i--; 12 | } 13 | } 14 | s = ans.substr(0, ans.size() - 1); 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /152-maximum-product-subarray.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProduct(int A[], int n) { 4 | int pos = 0, neg = 0; 5 | int ans = INT_MIN; 6 | for (int i = 0; i < n; i++) { 7 | if (A[i] == 0) { 8 | ans = max(0, ans); 9 | pos = neg = 0; 10 | } else { 11 | if (pos == 0) 12 | pos = A[i]; 13 | else 14 | pos *= A[i]; 15 | if (neg == 0) 16 | neg = A[i]; 17 | else 18 | neg *= A[i]; 19 | ans = max(ans, max(pos, neg)); 20 | int tmp = pos; 21 | pos = max(neg, pos); 22 | neg = min(tmp, neg); 23 | pos = (pos > 0 ? pos : 0); 24 | neg = (neg < 0 ? neg : 0); 25 | } 26 | } 27 | return ans; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /153-find-minimum-in-rotated-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findMin(vector &num) { 4 | int l = 0, r = num.size() - 1; 5 | while (l < r) { 6 | int mid = (l + r) >> 1; 7 | if (num[mid] > num[r]) 8 | l = mid + 1; 9 | else 10 | r = mid; 11 | } 12 | return num[l]; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /154-find-minimum-in-rotated-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findMin(vector &num) { 4 | int l = 0, r = num.size() - 1; 5 | while (l < r) { 6 | int mid = (l + r) >> 1; 7 | if (num[mid] > num[r]) 8 | l = mid + 1; 9 | else if (num[mid] < num[r]) 10 | r = mid; 11 | else 12 | r--; 13 | } 14 | return num[l]; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /155-min-stack.cpp: -------------------------------------------------------------------------------- 1 | class MinStack { 2 | public: 3 | void push(int x) { 4 | all.push(x); 5 | if (minone.empty() || x <= minone.top()) { 6 | minone.push(x); 7 | } 8 | } 9 | 10 | void pop() { 11 | if (minone.top() == all.top()) { 12 | minone.pop(); 13 | } 14 | all.pop(); 15 | } 16 | 17 | int top() { 18 | return all.top(); 19 | } 20 | 21 | int getMin() { 22 | return minone.top(); 23 | } 24 | 25 | private: 26 | stack minone; 27 | stack all; 28 | }; 29 | -------------------------------------------------------------------------------- /16-3sum-closest.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int threeSumClosest(vector &num, int target) { 4 | sort(num.begin(), num.end()); 5 | int ans = num[0] + num[1] + num[2], n = num.size(); 6 | for (int i = 0; i < n; i++) { 7 | for (int k = i + 1, j = n - 1; k < j;) { 8 | int v = num[i] + num[k] + num[j]; 9 | if (abs(v - target) < abs(ans - target)) 10 | ans = v; 11 | if (v > target) { 12 | j--; 13 | } else { 14 | k++; 15 | } 16 | } 17 | } 18 | return ans; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /160-intersection-of-two-linked-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { 12 | int lena = 0, lenb = 0; 13 | for (ListNode *head = headA; head; head = head->next) 14 | lena++; 15 | for (ListNode *head = headB; head; head = head->next) 16 | lenb++; 17 | for (int i = 0; i < lena - lenb; i++) 18 | headA = headA->next; 19 | for (int i = 0; i < lenb - lena; i++) 20 | headB = headB->next; 21 | for (int i = 0; i < min(lena, lenb); i++) { 22 | if (headA == headB) 23 | return headA; 24 | headA = headA->next; 25 | headB = headB->next; 26 | } 27 | return NULL; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /162-find-peak-element.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findPeakElement(const vector &num) { 4 | int l = 0, r = num.size() - 1; 5 | while (l < r) { 6 | int mid = (l + r) >> 1; 7 | if (mid + 1 < num.size() && num[mid + 1] > num[mid]) 8 | l = mid + 1; 9 | else 10 | r = mid; 11 | } 12 | return l; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /164-maximum-gap.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maximumGap(vector& nums) { 4 | if (nums.size() < 2) 5 | return 0; 6 | int max_value = INT_MIN; 7 | int min_value = INT_MAX; 8 | for (int i : nums) { 9 | max_value = max(max_value, i); 10 | min_value = min(min_value, i); 11 | } 12 | if (max_value == min_value) 13 | return 0; 14 | int bucket_size = (max_value - min_value) / nums.size() + 1; 15 | int bucket_len = (max_value - min_value) / bucket_size + 1; 16 | vector min_max(2, INT_MIN); 17 | min_max[0] = INT_MAX; 18 | vector > bucket(bucket_len, min_max); 19 | for (int i : nums) { 20 | int ind = (i - min_value) / bucket_size; 21 | bucket[ind][0] = min(i, bucket[ind][0]); 22 | bucket[ind][1] = max(i, bucket[ind][1]); 23 | } 24 | int ans = 0, pre = 0; 25 | for (int i = 1; i < bucket.size(); i++) { 26 | if (bucket[i][0] == INT_MAX) 27 | continue; 28 | ans = max(ans, bucket[i][0] - bucket[pre][1]); 29 | pre = i; 30 | } 31 | return ans; 32 | } 33 | }; -------------------------------------------------------------------------------- /165-compare-version-numbers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int compareVersion(string version1, string version2) { 4 | vector v1 = split(version1); 5 | vector v2 = split(version2); 6 | 7 | int pos = 0; 8 | while (pos < v1.size() && pos < v2.size()) { 9 | if (v1[pos] > v2[pos]) 10 | return 1; 11 | if (v1[pos] < v2[pos]) 12 | return -1; 13 | ++pos; 14 | } 15 | 16 | if (pos < v1.size()) { 17 | if (allZero(v1, pos)) 18 | return 0; 19 | return 1; 20 | } 21 | if (pos < v2.size()) { 22 | if (allZero(v2, pos)) 23 | return 0; 24 | return -1; 25 | } 26 | return 0; 27 | } 28 | 29 | private : 30 | vector split(string v) { 31 | vector ans; 32 | stringstream ss(v); 33 | string item; 34 | while(getline(ss, item, '.')) { 35 | ans.push_back(atoi(item.c_str())); 36 | } 37 | return ans; 38 | } 39 | 40 | bool allZero(vector v, int x) { 41 | for (int i = x; i < v.size(); i++) 42 | if (v[i] != 0) 43 | return false; 44 | return true; 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /166-fraction-to-recurring-decimal.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string fractionToDecimal(int numerator, int denominator) { 4 | if (numerator == 0) 5 | return "0"; 6 | string flag = "-"; 7 | if (((numerator < 0) ^ (denominator < 0)) == 0) 8 | flag = ""; 9 | long long num = abs(numerator * 1ll); 10 | long long den = abs(denominator * 1ll); 11 | long long integer = num / den; 12 | num %= den; 13 | if (num == 0) 14 | return flag + to_string(integer); 15 | return flag + to_string(integer) + "." + decimal(num, den); 16 | } 17 | 18 | private : 19 | string decimal(long long n, long long d) { 20 | unordered_map umap; 21 | string dec; 22 | umap[n] = 0; 23 | while (n != 0) { 24 | n *= 10; 25 | dec += to_string(n / d); 26 | n %= d; 27 | if (!umap.count(n)) { 28 | umap[n] = dec.size(); 29 | } else { 30 | int pos = umap[n]; 31 | return dec.substr(0, pos) + "(" + dec.substr(pos) + ")"; 32 | } 33 | } 34 | return dec; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /168-excel-sheet-column-title.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string convertToTitle(int n) { 4 | string ans; 5 | while (n) { 6 | ans = char('A' + (n - 1) % 26) + ans; 7 | n = (n - 1) / 26; 8 | } 9 | return ans; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /169-majority-element.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int majorityElement(vector &num) { 4 | int now = num[0], cnt = 1, len = num.size(); 5 | for (int i = 1; i < len; i++) { 6 | if (num[i] == now) { 7 | cnt++; 8 | } else { 9 | cnt--; 10 | if (cnt <= 0) { 11 | cnt = 1; 12 | now = num[i]; 13 | } 14 | } 15 | } 16 | return now; 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /17-letter-combinations-of-a-phone-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector letterCombinations(string digits) { 4 | dfs(0, digits, ""); 5 | return ans; 6 | } 7 | private: 8 | const vector alp = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}; 9 | vector ans; 10 | 11 | void dfs(int x, string &digits, string s) { 12 | if (x == digits.size()) { 13 | ans.push_back(s); 14 | return ; 15 | } 16 | int pos = digits[x] - '0'; 17 | for (int k = 0; k < alp[pos].size(); k++) { 18 | dfs(x + 1, digits, s + alp[pos][k]); 19 | } 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /171-excel-sheet-column-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int titleToNumber(string s) { 4 | int ans = 0; 5 | for (int i = 0; i < s.size(); i++) { 6 | ans *= 26; 7 | ans += s[i] - 'A' + 1; 8 | } 9 | return ans; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /172-factorial-trailing-zeroes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int trailingZeroes(int n) { 4 | int ans = 0; 5 | while (n) { 6 | ans += n / 5; 7 | n /= 5; 8 | } 9 | return ans; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /173-binary-search-tree-iterator.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class BSTIterator { 11 | public: 12 | BSTIterator(TreeNode *root) { 13 | pushLeft(root); 14 | } 15 | 16 | /** @return whether we have a next smallest number */ 17 | bool hasNext() { 18 | return !stk.empty(); 19 | } 20 | 21 | /** @return the next smallest number */ 22 | int next() { 23 | int v = stk.top()->val; 24 | TreeNode* root = stk.top()->right; 25 | stk.pop(); 26 | pushLeft(root); 27 | return v; 28 | } 29 | 30 | private : 31 | stack stk; 32 | void pushLeft(TreeNode *root) { 33 | while (root) { 34 | stk.push(root); 35 | root = root->left; 36 | } 37 | } 38 | }; 39 | 40 | /** 41 | * Your BSTIterator will be called like this: 42 | * BSTIterator i = BSTIterator(root); 43 | * while (i.hasNext()) cout << i.next(); 44 | */ 45 | -------------------------------------------------------------------------------- /174-dungeon-game.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int calculateMinimumHP(vector>& d) { 4 | vector> dp(d.size(), vector(d[0].size(), 0)); 5 | int n = d.size(); 6 | int m = d[0].size(); 7 | dp[n - 1][m - 1] = max(1, 1 - d[n - 1][m - 1]); 8 | for (int i = n - 2; i >= 0; i--) 9 | dp[i][m - 1] = max(1, dp[i + 1][m - 1] - d[i][m - 1]); 10 | for (int k = m - 2; k >= 0; k--) 11 | dp[n - 1][k] = max(1, dp[n - 1][k + 1] - d[n - 1][k]); 12 | 13 | for (int i = n - 2; i >= 0; i--) { 14 | for (int k = m - 2; k >= 0; k--) { 15 | dp[i][k] = max(1, min(dp[i + 1][k], dp[i][k + 1]) - d[i][k]); 16 | } 17 | } 18 | 19 | return dp[0][0]; 20 | } 21 | }; -------------------------------------------------------------------------------- /179-largest-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string largestNumber(vector& nums) { 4 | vector s; 5 | for (int i : nums) 6 | s.push_back(to_string(i)); 7 | sort(s.begin(), s.end(), compare); 8 | string ans; 9 | for(const string& str : s) 10 | ans += str; 11 | if (ans[0] == '0') 12 | return "0"; 13 | return ans; 14 | } 15 | 16 | private : 17 | static bool compare(const string& s1, const string& s2) { 18 | return s1 + s2 > s2 + s1; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /18-4sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > fourSum(vector &num, int target) { 4 | vector > ans; 5 | sort(num.begin(), num.end()); 6 | for (int i = 0; i < num.size(); i++) { 7 | for (int k = i + 1; k < num.size(); k++) { 8 | int x = target - num[i] - num[k]; 9 | for (int l = k + 1, r = num.size() - 1; l < r;) { 10 | if (num[l] + num[r] > x) { 11 | r--; 12 | } else if (num[l] + num[r] < x) { 13 | l++; 14 | } else { 15 | vector t = {num[i], num[k], num[l], num[r]}; 16 | if (ans.size() == 0 || t != ans.back()) 17 | ans.push_back(t); 18 | l++; r--; 19 | } 20 | } 21 | } 22 | } 23 | sort(ans.begin(), ans.end()); 24 | ans.resize(unique(ans.begin(), ans.end()) - ans.begin()); 25 | return ans; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /187-repeated-dna-sequences.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector findRepeatedDnaSequences(string s) { 4 | unordered_map umap; 5 | vector ans; 6 | if (s.size() < 10) 7 | return ans; 8 | for (int i = 0; i <= s.size() - 10; i++) { 9 | string sub = s.substr(i, 10); 10 | int h = hash(sub); 11 | if (umap.count(h) && umap[h] == 1) { 12 | ans.push_back(sub); 13 | } 14 | umap[h] += 1; 15 | } 16 | return ans; 17 | } 18 | private : 19 | const int eraser = 0x3ffff; 20 | unordered_map ati{{'A', 0}, {'C', 1}, {'G', 2}, {'T', 3}}; 21 | int hash(string s) { 22 | int ans = 0; 23 | for (int i = 0; i < s.size(); i++) 24 | ans = ((ans & eraser) << 2) + ati[s[i]]; 25 | return ans; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /188-best-time-to-buy-and-sell-stock-iv.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(int k, vector& prices) { 4 | if (prices.size() < 2 || k == 0) 5 | return 0; 6 | if (k >= prices.size() / 2) 7 | return calculateMaxProfit(prices); 8 | vector > dp(k + 1, vector{INT_MIN, 0}); 9 | for (int i = 0; i < prices.size(); i++) { 10 | for (int t = 1; t <= k; t++) { 11 | dp[t][BUY] = max(dp[t][BUY], dp[t - 1][SELL] - prices[i]); 12 | dp[t][SELL] = max(dp[t][SELL], dp[t][BUY] + prices[i]); 13 | } 14 | } 15 | return dp[k][SELL]; 16 | } 17 | private : 18 | const int BUY = 0; 19 | const int SELL = 1; 20 | int calculateMaxProfit(vector &prices) { 21 | int ans = 0; 22 | for (int i = 1; i < prices.size(); i++) { 23 | if (prices[i] > prices[i - 1]) 24 | ans += prices[i] - prices[i - 1]; 25 | } 26 | return ans; 27 | } 28 | }; -------------------------------------------------------------------------------- /189-rotate-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void rotate(int nums[], int n, int k) { 4 | k %= n; 5 | swapArray(nums, n - k); 6 | swapArray(nums + n - k, k); 7 | swapArray(nums, n); 8 | } 9 | 10 | private : 11 | void swapArray(int* num, int n) { 12 | for (int i = 0; i < n / 2; i++) 13 | swap(num[i], num[n - i - 1]); 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /19-remove-nth-node-from-end-of-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *removeNthFromEnd(ListNode *head, int n) { 12 | ListNode* first = head; 13 | ListNode* second = head; 14 | ListNode* pre = head; 15 | for(int i = 0; i < n; i++) 16 | first = first->next; 17 | if( first == NULL ) 18 | return head->next; 19 | while( first ) { 20 | pre = second; 21 | second = second->next; 22 | first = first->next; 23 | } 24 | pre->next = second->next; 25 | return head; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /190-reverse-bits.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | uint32_t reverseBits(uint32_t n) { 4 | uint32_t ans = 0; 5 | 6 | for (int i = 0; i < 32; i++) { 7 | ans <<= 1; 8 | ans |= (n & 1); 9 | n >>= 1; 10 | } 11 | 12 | return ans; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /191-number-of-1-bits.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int hammingWeight(uint32_t n) { 4 | int ans = 0; 5 | while (n) { 6 | ans++; 7 | n &= (n - 1); 8 | } 9 | return ans; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /198-house-robber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int rob(vector& nums) { 4 | if (nums.size() == 0) 5 | return 0; 6 | vector dp(nums.size(), 0); 7 | dp[0] = nums[0]; 8 | if (nums.size() > 1) 9 | dp[1] = max(nums[0], nums[1]); 10 | for (int i = 2; i < nums.size(); i++) { 11 | dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]); 12 | } 13 | return dp.back(); 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /199-binary-tree-right-side-view.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector rightSideView(TreeNode *root) { 13 | vector ans; 14 | if (root == NULL) 15 | return ans; 16 | queue q; 17 | q.push(root); 18 | while (!q.empty()) { 19 | ans.push_back(q.back()->val); 20 | int n = q.size(); 21 | for (int i = 0; i < n; i++) { 22 | TreeNode *now = q.front(); 23 | q.pop(); 24 | if (now->left) 25 | q.push(now->left); 26 | if (now->right) 27 | q.push(now->right); 28 | } 29 | } 30 | return ans; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /2-Add-Two-Numbers.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) { 12 | ListNode ans(0); 13 | ListNode *sum = &ans; 14 | int carry = 0; 15 | while (l1 || l2 || carry) { 16 | int s = carry; 17 | if (l1) { 18 | s += l1->val; 19 | l1 = l1->next; 20 | } 21 | if (l2) { 22 | s += l2->val; 23 | l2 = l2->next; 24 | } 25 | carry = s / 10; 26 | sum->next = new ListNode(s % 10); 27 | sum = sum->next; 28 | } 29 | return ans.next; 30 | } 31 | }; -------------------------------------------------------------------------------- /20-valid-parentheses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | stack stk; 4 | bool isValid(string s) { 5 | for (int i = 0; i < s.size(); i++) { 6 | if (s[i] == '(' || s[i] == '{' || s[i] == '[') { 7 | stk.push(s[i]); 8 | } else { 9 | if (!stk.empty() && (s[i] == ')' && s[i] - 1 == stk.top() || s[i] - 2 == stk.top())) { 10 | stk.pop(); 11 | } else { 12 | return false; 13 | } 14 | } 15 | } 16 | return stk.empty(); 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /200-number-of-islands.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numIslands(vector>& grid) { 4 | int ans = 0; 5 | vector> t(grid); 6 | for (int i = 0; i < t.size(); i++) { 7 | for (int k = 0; k < t[i].size(); k++) { 8 | if (t[i][k] == '1') { 9 | dfs(i, k, t); 10 | ans++; 11 | } 12 | } 13 | } 14 | return ans; 15 | } 16 | 17 | private : 18 | int dir[8] = {0, 1, 0, -1, -1, 0, 1, 0}; 19 | void dfs(int x, int y, vector>& grid) { 20 | grid[x][y] = '0'; 21 | for (int i = 0; i < 8; i += 2) { 22 | int xx = x + dir[i]; 23 | int yy = y + dir[i + 1]; 24 | if (xx >= 0 && xx < grid.size() && yy >= 0 && yy < grid[xx].size() && grid[xx][yy] == '1') { 25 | dfs(xx, yy, grid); 26 | } 27 | } 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /201-bitwise-and-of-numbers-range-1.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int rangeBitwiseAnd(int m, int n) { 4 | int t = n; 5 | int ans = 0; 6 | for (int i = 0; n != 0; i++) { 7 | long long k = (1ll << i); 8 | if ((t & k) == 0) { 9 | t += k; 10 | } else if (t - k < m) { 11 | ans += k; 12 | } 13 | n /= 2; 14 | } 15 | return ans; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /201-bitwise-and-of-numbers-range-2.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int rangeBitwiseAnd(int m, int n) { 4 | int t = 0; 5 | while (m != n) { 6 | m >>= 1; 7 | n >>= 1; 8 | t++; 9 | } 10 | return (m << t); 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /202-happy-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isHappy(int n) { 4 | while (!st.count(n)) { 5 | st.insert(n); 6 | int t = 0; 7 | while (n != 0) { 8 | int k = n % 10; 9 | t += k * k; 10 | n /= 10; 11 | } 12 | n = t; 13 | if (n == 1) 14 | return true; 15 | } 16 | return false; 17 | } 18 | 19 | private : 20 | unordered_set st; 21 | }; 22 | -------------------------------------------------------------------------------- /203-remove-linked-list-elements.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode* removeElements(ListNode* head, int val) { 12 | ListNode *h = new ListNode(0); 13 | h->next = head; 14 | ListNode *t = h; 15 | while (t != NULL && t->next != NULL) { 16 | if (t->next->val == val) { 17 | t->next = t->next->next; 18 | } else { 19 | t = t->next; 20 | } 21 | } 22 | return h->next; 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /204-count-primes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int countPrimes(int n) { 4 | bool flag[n]; 5 | memset(flag, 0, sizeof(flag)); 6 | int bound = sqrt(n); 7 | int cnt = n - 2 < 0 ? 0 : n - 2; 8 | for (int i = 2; i <= bound; i++) { 9 | if (flag[i]) 10 | continue; 11 | for (int k = i * i; k < n; k += i) { 12 | if (!flag[k]) { 13 | flag[k] = true; 14 | cnt--; 15 | } 16 | } 17 | } 18 | return cnt; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /205-isomorphic-strings.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isIsomorphic(string s, string t) { 4 | if (s.size() != t.size()) 5 | return false; 6 | vector m(260, -1); 7 | vector in(260, false); 8 | for (int i = 0; i < s.size(); i++) { 9 | if (m[s[i]] == -1) { 10 | m[s[i]] = t[i]; 11 | if (in[t[i]]) 12 | return false; 13 | in[t[i]] = true; 14 | } else if (m[s[i]] != t[i]) { 15 | return false; 16 | } 17 | } 18 | return true; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /206-reverse-linked-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode* reverseList(ListNode* head) { 12 | reverse(head); 13 | return ans; 14 | } 15 | 16 | private : 17 | ListNode* ans = NULL; 18 | ListNode* reverse(ListNode* head) { 19 | if (head == NULL || head->next == NULL) { 20 | ans = head; 21 | return head; 22 | } 23 | ListNode* p = reverse(head->next); 24 | head->next = NULL; 25 | p->next = head; 26 | return p->next; 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /207-course-schedule.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool canFinish(int numCourses, vector>& prerequisites) { 4 | vector > list(numCourses); 5 | vector in_degree(numCourses, 0); 6 | for (int i = 0; i < prerequisites.size(); i++) { 7 | list[prerequisites[i].second].push_back(prerequisites[i].first); 8 | in_degree[prerequisites[i].first]++; 9 | } 10 | queue q; 11 | for (int i = 0; i < numCourses; i++) { 12 | if (in_degree[i] == 0) 13 | q.push(i); 14 | } 15 | int cnt = q.size(); 16 | while (!q.empty()) { 17 | int x = q.front(); 18 | q.pop(); 19 | for (int i = 0; i < list[x].size(); i++) { 20 | in_degree[list[x][i]]--; 21 | if (in_degree[list[x][i]] == 0) { 22 | q.push(list[x][i]); 23 | cnt++; 24 | } 25 | } 26 | } 27 | return cnt == numCourses; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /208-implement-trie-prefix-tree.cpp: -------------------------------------------------------------------------------- 1 | class TrieNode { 2 | public: 3 | // Initialize your data structure here. 4 | vector child; 5 | bool end; 6 | TrieNode() : child(26, NULL), end(false) { 7 | } 8 | }; 9 | 10 | class Trie { 11 | public: 12 | Trie() { 13 | root = new TrieNode(); 14 | } 15 | 16 | // Inserts a word into the trie. 17 | void insert(string s) { 18 | TrieNode *head = root; 19 | for (int i = 0; i < s.size(); i++) { 20 | if (head->child[s[i] - 'a'] == NULL) { 21 | head->child[s[i] - 'a'] = new TrieNode(); 22 | } 23 | head = head->child[s[i] - 'a']; 24 | } 25 | head->end = true; 26 | } 27 | 28 | // Returns if the word is in the trie. 29 | bool search(string key) { 30 | TrieNode *head = root; 31 | for (int i = 0; i < key.size(); i++) { 32 | if (head->child[key[i] - 'a'] == NULL) { 33 | return false; 34 | } 35 | head = head->child[key[i] - 'a']; 36 | } 37 | return head->end; 38 | } 39 | 40 | // Returns if there is any word in the trie 41 | // that starts with the given prefix. 42 | bool startsWith(string prefix) { 43 | TrieNode *head = root; 44 | for (int i = 0; i < prefix.size(); i++) { 45 | if (head->child[prefix[i] - 'a'] == NULL) { 46 | return false; 47 | } 48 | head = head->child[prefix[i] - 'a']; 49 | } 50 | return true; 51 | } 52 | 53 | private: 54 | TrieNode* root; 55 | }; 56 | 57 | // Your Trie object will be instantiated and called as such: 58 | // Trie trie; 59 | // trie.insert("somestring"); 60 | // trie.search("key"); 61 | -------------------------------------------------------------------------------- /209-minimum-size-subarray-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minSubArrayLen(int s, vector& nums) { 4 | int l = 0; 5 | int sum = 0; 6 | int min_len = nums.size() + 1; 7 | for (int i = 0; i < nums.size(); i++) { 8 | sum += nums[i]; 9 | if (sum >= s) { 10 | min_len = min(min_len, i - l + 1); 11 | } 12 | while (sum - nums[l] >= s) { 13 | sum -= nums[l]; 14 | l++; 15 | min_len = min(min_len, i - l + 1); 16 | } 17 | } 18 | return min_len > nums.size() ? 0 : min_len; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /21-merge-two-sorted-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) { 12 | ListNode* ans = new ListNode(0); 13 | ListNode* head = ans; 14 | while( l1 || l2 ) { 15 | if( l1 == NULL ) { 16 | ans->next = l2; 17 | break; 18 | } 19 | if( l2 == NULL ) { 20 | ans->next = l1; 21 | break; 22 | } 23 | if( l1->val < l2->val ) { 24 | ans->next = l1; 25 | l1 = l1->next; 26 | } else { 27 | ans->next = l2; 28 | l2 = l2->next; 29 | } 30 | ans = ans->next; 31 | } 32 | return head->next; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /210-course-schedule-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector findOrder(int numCourses, vector>& prerequisites) { 4 | vector > list(numCourses); 5 | vector in_degree(numCourses, 0); 6 | vector order; 7 | for (int i = 0; i < prerequisites.size(); i++) { 8 | list[prerequisites[i].second].push_back(prerequisites[i].first); 9 | in_degree[prerequisites[i].first]++; 10 | } 11 | queue q; 12 | for (int i = 0; i < numCourses; i++) { 13 | if (in_degree[i] == 0) 14 | q.push(i); 15 | } 16 | int cnt = q.size(); 17 | while (!q.empty()) { 18 | int x = q.front(); 19 | order.push_back(x); 20 | q.pop(); 21 | for (int i = 0; i < list[x].size(); i++) { 22 | if (--in_degree[list[x][i]] == 0) { 23 | q.push(list[x][i]); 24 | cnt++; 25 | } 26 | } 27 | } 28 | return cnt == numCourses ? order : vector(); 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /211-add-and-search-word-data-structure-design.cpp: -------------------------------------------------------------------------------- 1 | class TrieNode { 2 | public: 3 | vector child; 4 | int max_len; //剪枝 5 | bool end; 6 | TrieNode() : child(26, NULL), end(false), max_len(0) { 7 | } 8 | }; 9 | 10 | class WordDictionary { 11 | public: 12 | 13 | WordDictionary() { 14 | root = new TrieNode(); 15 | } 16 | // Adds a word into the data structure. 17 | void addWord(string word) { 18 | TrieNode *head = root; 19 | for (int i = 0; i < word.size(); i++) { 20 | head->max_len = max(head->max_len, int(word.size() - i)); 21 | int id = word[i] - 'a'; 22 | if (head->child[id] == NULL) { 23 | head->child[id] = new TrieNode(); 24 | } 25 | head = head->child[id]; 26 | } 27 | head->end = true; 28 | } 29 | 30 | // Returns if the word is in the data structure. A word could 31 | // contain the dot character '.' to represent any one letter. 32 | bool search(string word) { 33 | return dfs(root, word, 0); 34 | } 35 | 36 | bool dfs(TrieNode *root, string &word, int x) { 37 | if (root == NULL) 38 | return false; 39 | if (x == word.size()) 40 | return root->end; 41 | if (root->max_len < word.size() - x) 42 | return false; 43 | if (word[x] != '.') 44 | return dfs(root->child[word[x] - 'a'], word, x + 1); 45 | for (int i = 0; i < root->child.size(); i++) { 46 | if (dfs(root->child[i], word, x + 1)) 47 | return true; 48 | } 49 | return false; 50 | } 51 | 52 | private: 53 | TrieNode *root; 54 | }; 55 | 56 | // Your WordDictionary object will be instantiated and called as such: 57 | // WordDictionary wordDictionary; 58 | // wordDictionary.addWord("word"); 59 | // wordDictionary.search("pattern"); 60 | -------------------------------------------------------------------------------- /212-word-search-ii.cpp: -------------------------------------------------------------------------------- 1 | class TrieNode { 2 | public: 3 | // Initialize your data structure here. 4 | vector child; 5 | bool end; 6 | TrieNode() : child(26, NULL), end(false) { 7 | } 8 | }; 9 | 10 | class Trie { 11 | public: 12 | Trie() { 13 | root = new TrieNode(); 14 | } 15 | 16 | // Inserts a word into the trie. 17 | void insert(string s) { 18 | TrieNode *head = root; 19 | for (int i = 0; i < s.size(); i++) { 20 | if (head->child[s[i] - 'a'] == NULL) { 21 | head->child[s[i] - 'a'] = new TrieNode(); 22 | } 23 | head = head->child[s[i] - 'a']; 24 | } 25 | head->end = true; 26 | } 27 | 28 | // Returns if the word is in the trie. 29 | bool search(string key) { 30 | TrieNode *head = root; 31 | for (int i = 0; i < key.size(); i++) { 32 | if (head->child[key[i] - 'a'] == NULL) { 33 | return false; 34 | } 35 | head = head->child[key[i] - 'a']; 36 | } 37 | if (head->end) { 38 | head->end = false; 39 | return true; 40 | } 41 | return false; 42 | } 43 | 44 | // Returns if there is any word in the trie 45 | // that starts with the given prefix. 46 | bool startsWith(string prefix) { 47 | TrieNode *head = root; 48 | for (int i = 0; i < prefix.size(); i++) { 49 | if (head->child[prefix[i] - 'a'] == NULL) { 50 | return false; 51 | } 52 | head = head->child[prefix[i] - 'a']; 53 | } 54 | return true; 55 | } 56 | 57 | private: 58 | TrieNode* root; 59 | }; 60 | class Solution { 61 | public: 62 | vector findWords(vector>& board, vector& words) { 63 | vector ans; 64 | Trie trie; 65 | for (auto &str : words) 66 | trie.insert(str); 67 | int n = board.size(); 68 | if (n == 0) 69 | return ans; 70 | int m = board[0].size(); 71 | vector> visited(n, vector(m, false)); 72 | string str; 73 | for (int i = 0; i < n; i++) { 74 | for (int k = 0; k < m; k++) { 75 | str.push_back(board[i][k]); 76 | dfs(i, k, trie, str, ans, board, visited); 77 | str.pop_back(); 78 | } 79 | } 80 | return ans; 81 | } 82 | 83 | private : 84 | int dir[8] = {0, 1, 0, -1, -1, 0, 1, 0}; 85 | void dfs(int x, int y, Trie &trie, string &str, vector &ans, vector>& board, vector>& visited) { 86 | if (!trie.startsWith(str)) 87 | return ; 88 | if (trie.search(str)) 89 | ans.push_back(str); 90 | visited[x][y] = true; 91 | for (int i = 0; i < 8; i += 2) { 92 | int xx = x + dir[i]; 93 | int yy = y + dir[i + 1]; 94 | if (xx >= 0 && xx < board.size() && yy >= 0 && yy < board[0].size() && !visited[xx][yy]) { 95 | str.push_back(board[xx][yy]); 96 | dfs(xx, yy, trie, str, ans, board, visited); 97 | str.pop_back(); 98 | } 99 | } 100 | visited[x][y] = false; 101 | } 102 | }; 103 | 104 | -------------------------------------------------------------------------------- /213-house-robber-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int rob(vector& nums) { 4 | if (nums.size() == 0) 5 | return 0; 6 | if (nums.size() == 1) 7 | return nums[0]; 8 | vector > dp(2, vector(nums.size(), 0)); 9 | int ans = nums[0]; 10 | dp[0][0] = nums[0]; 11 | dp[1][1] = nums[1]; 12 | ans = max(ans, nums[1]); 13 | for (int i = 2; i < nums.size(); i++) { 14 | for (int k = i - 2; k >= i - 3; k--) { 15 | if (i != nums.size() - 1) 16 | dp[0][i] = max(dp[0][k] + nums[i], dp[0][i]); 17 | dp[1][i] = max(dp[1][k] + nums[i], dp[1][i]); 18 | } 19 | ans = max(ans, max(dp[0][i], dp[1][i])); 20 | } 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /215-kth-largest-element-in-an-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findKthLargest(vector& nums, int k) { 4 | k = nums.size() - k; 5 | int l = 0, r = nums.size() - 1; 6 | while (true) { 7 | int pos = partition(nums, l, r); 8 | if (pos == k) 9 | return nums[pos]; 10 | if (pos > k) { 11 | r = pos - 1; 12 | } else { 13 | l = pos + 1; 14 | } 15 | } 16 | } 17 | 18 | private : 19 | int partition(vector& nums, int l, int r) { 20 | int p = l; 21 | for (int i = l; i <= r; i++) { 22 | if (nums[i] <= nums[r]) { 23 | swap(nums[i], nums[p++]); 24 | } 25 | } 26 | return p - 1; 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /216-combination-sum-iii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> combinationSum3(int k, int n) { 4 | vector> ans; 5 | if (n > 55) 6 | return ans; 7 | vector t; 8 | dfs(0, 0, k, n, ans, t); 9 | return ans; 10 | } 11 | private : 12 | void dfs(int x, int sum, int k, int n, vector> &ans, vector &t) { 13 | if (t.size() == k && sum == n) { 14 | ans.push_back(t); 15 | return ; 16 | } 17 | if (t.size() == k || sum == n) { 18 | return ; 19 | } 20 | for (int i = x + 1; i <= 9; i++) { 21 | if (sum + i <= n) { 22 | t.push_back(i); 23 | dfs(i, sum + i, k, n, ans, t); 24 | t.pop_back(); 25 | } else { 26 | break; 27 | } 28 | } 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /217-contains-duplicate.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool containsDuplicate(vector& nums) { 4 | unordered_set uset; 5 | for (int i : nums) { 6 | if (uset.count(i)) 7 | return true; 8 | uset.insert(i); 9 | } 10 | return false; 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /218-the-skyline-problem.cpp: -------------------------------------------------------------------------------- 1 | class line { 2 | public : 3 | line(int x, int y, int op) : x(x), y(y), op(op) {} 4 | line() {} 5 | int x, y; 6 | int op; 7 | }; 8 | bool cmp(const line &a, const line &b) { 9 | if (a.x == b.x && a.op == b.op && a.op == 1) 10 | return a.y > b.y; 11 | if (a.x == b.x && a.op == b.op && a.op == -1) 12 | return a.y < b.y; 13 | if (a.x == b.x) 14 | return a.op > b.op; 15 | return a.x < b.x; 16 | } 17 | class Solution { 18 | public: 19 | vector > getSkyline(vector >& buildings) { 20 | vector > ans; 21 | map > mp; 22 | vector lv; 23 | line t; 24 | for (int i = 0; i < buildings.size(); i++) { 25 | line t(buildings[i][0], buildings[i][2], 1); 26 | lv.push_back(t); 27 | t.op = -1; 28 | t.x = buildings[i][1]; 29 | lv.push_back(t); 30 | } 31 | sort(lv.begin(), lv.end(), cmp); 32 | for (line &t : lv) { 33 | if (t.op == 1) { 34 | int cnt = ++mp[t.y]; 35 | if (cnt == 1 && mp.begin()->first == t.y) { 36 | ans.push_back(make_pair(t.x, t.y)); 37 | } 38 | } else { 39 | int cnt = --mp[t.y]; 40 | if (cnt == 0 && t.y == mp.begin()->first) { 41 | mp.erase(t.y); 42 | if (mp.empty()) { 43 | ans.push_back(make_pair(t.x, 0)); 44 | } else { 45 | ans.push_back(make_pair(t.x, mp.begin()->first)); 46 | } 47 | continue; 48 | } 49 | if (cnt == 0) 50 | mp.erase(t.y); 51 | } 52 | } 53 | return ans; 54 | } 55 | }; 56 | -------------------------------------------------------------------------------- /219-contains-duplicate-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool containsNearbyDuplicate(vector& nums, int k) { 4 | unordered_map umap; 5 | for (int i = 0; i < nums.size(); i++) { 6 | if (umap.count(nums[i])) { 7 | if (i - umap[nums[i]] <= k) 8 | return true; 9 | } 10 | umap[nums[i]] = i; 11 | } 12 | return false; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /22-generate-parentheses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector generateParenthesis(int n) { 4 | dfs("", n, 0); 5 | return ans; 6 | } 7 | 8 | private: 9 | vector ans; 10 | void dfs(string s, int n, int sum) { 11 | if (s.size() == n * 2) { 12 | if (sum == 0) 13 | ans.push_back(s); 14 | return ; 15 | } 16 | 17 | if (sum - 1 >= 0) 18 | dfs(s + ')', n, sum - 1); 19 | if (sum + 1 <= n) 20 | dfs(s + '(', n, sum + 1); 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /220-contains-duplicate-iii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool containsNearbyAlmostDuplicate(vector& nums, int k, int t) { 4 | if (k == 0) 5 | return false; 6 | map mp; 7 | int l = 0; 8 | int cnt = 0; 9 | for (int i = 0; i < nums.size(); i++) { 10 | if (cnt == k + 1) { 11 | int count = --mp[nums[l]]; 12 | if (count == 0) 13 | mp.erase(nums[l]); 14 | cnt--; 15 | l++; 16 | } 17 | auto it = mp.lower_bound(nums[i] - t); 18 | if (it != mp.end() && abs(it->first - nums[i]) <= t) 19 | return true; 20 | it = mp.lower_bound(nums[i]); 21 | if (it != mp.end() && abs(it->first - nums[i]) <= t) 22 | return true; 23 | mp[nums[i]]++; 24 | cnt++; 25 | } 26 | return false; 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /222-count-complete-tree-nodes.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int countNodes(TreeNode* root) { 13 | if (root == NULL) 14 | return 0; 15 | int h = calculateH(root); 16 | h--; 17 | int sum = (1 << h) - 1; 18 | int l = 1, r = (1 << h); 19 | int mid = 0; 20 | while (l < r) { 21 | mid = (l + r) >> 1; 22 | if (check(mid, h - 1, root)) { 23 | l = mid + 1; 24 | } else { 25 | r = mid; 26 | } 27 | } 28 | return sum + r; 29 | } 30 | 31 | private : 32 | bool check(int path, int h, TreeNode *root) { 33 | if (h == -1) { 34 | return root != NULL; 35 | } 36 | if (root == NULL) { 37 | return false; 38 | } 39 | if (path & (1 << h)) { 40 | return check(path, h - 1, root->right); 41 | } 42 | return check(path, h - 1, root->left); 43 | } 44 | int calculateH(TreeNode *root) { 45 | TreeNode *head = root; 46 | int h = 0; 47 | while (head) { 48 | h++; 49 | head = head->left; 50 | } 51 | return h; 52 | } 53 | }; 54 | -------------------------------------------------------------------------------- /223-rectangle-area.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) { 4 | int area = (C - A) * (D - B) + (G - E) * (H - F); 5 | if (B >= H || F >= D || A >= G || E >= D) 6 | return area; 7 | int top = min(D, H); 8 | int bottom = max(B, F); 9 | int left = max(A, E); 10 | int right = min(C, G); 11 | return area - (top - bottom) * (right - left); 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /224-basic-calculator.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int calculate(string s) { 4 | stack op; 5 | stack num; 6 | for (int i = 0; i < s.size(); i++) { 7 | char ch = s[i]; 8 | if (ch == ' ') 9 | continue; 10 | if (ch == '(' || ch == '+' || ch == '-') { 11 | op.push(s[i]); 12 | continue; 13 | } 14 | if (ch == ')' && op.top() == '(') 15 | op.pop(); 16 | if (isdigit(ch)) { 17 | int n = 0; 18 | while (i < s.size() && isdigit(s[i])) { 19 | n = n * 10 + s[i] - '0'; 20 | i++; 21 | } 22 | num.push(n); 23 | i--; 24 | } 25 | if (!op.empty() && (op.top() == '+' || op.top() == '-')) { 26 | int b = num.top(); num.pop(); 27 | int a = num.top(); num.pop(); 28 | num.push(calcWithOp(a, b, op.top())); 29 | op.pop(); 30 | } 31 | } 32 | return num.top(); 33 | } 34 | private : 35 | int calcWithOp(int a, int b, char op) { 36 | if (op == '+') 37 | return a + b; 38 | return a - b; 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /225-implement-stack-using-queues.cpp: -------------------------------------------------------------------------------- 1 | class Stack { 2 | public: 3 | vector v; 4 | // Push element x onto stack. 5 | void push(int x) { 6 | v.push_back(x); 7 | } 8 | 9 | // Removes the element on top of the stack. 10 | void pop(void) { 11 | v.pop_back(); 12 | } 13 | 14 | // Get the top element. 15 | int top(void) { 16 | return v.back(); 17 | } 18 | 19 | // Return whether the stack is empty. 20 | bool empty(void) { 21 | return v.size() == 0; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /226-invert-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode* invertTree(TreeNode* root) { 13 | if (root != NULL) { 14 | swap(root->left, root->right); 15 | invertTree(root->left); 16 | invertTree(root->right); 17 | } 18 | return root; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /227-basic-calculator-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int calculate(string s) { 4 | vector op; 5 | vector num; 6 | for (int i = 0; i < s.size(); i++) { 7 | char ch = s[i]; 8 | if (ch == ' ') 9 | continue; 10 | if (!isdigit(ch)) { 11 | op.push_back(s[i]); 12 | continue; 13 | } else { 14 | num.push_back(sumNumber(i, s)); 15 | if (!op.empty() && (op.back() == '*' || op.back() == '/')) { 16 | int b = num.back(); num.pop_back(); 17 | int a = num.back(); num.pop_back(); 18 | num.push_back(calcWithOp(a, b, op.back())); 19 | op.pop_back(); 20 | } 21 | } 22 | } 23 | int ans = num[0]; 24 | for (int i = 0; i < op.size(); i++) 25 | ans = calcWithOp(ans, num[i + 1], op[i]); 26 | return ans; 27 | } 28 | private : 29 | int sumNumber(int& i, string& s) { 30 | int n = 0; 31 | while (i < s.size() && isdigit(s[i])) { 32 | n = n * 10 + s[i] - '0'; 33 | i++; 34 | } 35 | i--; 36 | return n; 37 | } 38 | int calcWithOp(int a, int b, char op) { 39 | switch (op) { 40 | case '+' : return a + b; 41 | case '-' : return a - b; 42 | case '*' : return a * b; 43 | case '/' : return a / b; 44 | } 45 | } 46 | }; -------------------------------------------------------------------------------- /228-summary-ranges.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector summaryRanges(vector& nums) { 4 | vector ans; 5 | if (nums.size() == 0) 6 | return ans; 7 | int n = nums.size(); 8 | for (int i = 0; i < n; i++) { 9 | int t = i; 10 | while (i + 1 < n && nums[i + 1] - nums[i] == 1) 11 | i++; 12 | ans.push_back(to_string(nums[t])); 13 | if (i != t) 14 | ans.back() += "->" + to_string(nums[i]); 15 | } 16 | return ans; 17 | } 18 | }; -------------------------------------------------------------------------------- /229-majority-element-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector majorityElement(vector& nums) { 4 | vector ans; 5 | vector value(2, 0), cnt(2, 0); 6 | for (int &x : nums) { 7 | calculate(value, cnt, x); 8 | } 9 | if (isMajority(nums, value[0])) 10 | ans.push_back(value[0]); 11 | if (value[0] != value[1] && isMajority(nums, value[1])) 12 | ans.push_back(value[1]); 13 | return ans; 14 | } 15 | private : 16 | bool isMajority(vector& nums, int x) { 17 | int sum = 0; 18 | for (int &k : nums) 19 | sum += (k == x ? 1 : 0); 20 | return sum > nums.size() / 3; 21 | } 22 | void calculate(vector &value, vector &cnt, int x) { 23 | for (int i = 0; i < 2; i++) { 24 | if (cnt[i] != 0 && value[i] == x) { 25 | cnt[i]++; 26 | return ; 27 | } 28 | } 29 | for (int i = 0; i < 2; i++) { 30 | if (cnt[i] == 0) { 31 | value[i] = x; 32 | cnt[i] = 1; 33 | return ; 34 | } 35 | } 36 | for (int& c : cnt) { 37 | if (c > 0) 38 | c--; 39 | } 40 | } 41 | }; -------------------------------------------------------------------------------- /23-merge-k-sorted-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | struct cmp{ 12 | bool operator()(const ListNode* a, const ListNode* b) { 13 | return a->val > b->val; 14 | } 15 | }; 16 | ListNode *mergeKLists(vector &lists) { 17 | priority_queue, cmp> q; 18 | ListNode ans = ListNode(0); 19 | ListNode* ahead = &ans; 20 | 21 | for (int i = 0; i < lists.size(); i++) { 22 | if (lists[i]) 23 | q.push(lists[i]); 24 | } 25 | while (!q.empty()){ 26 | ListNode* head = q.top(); 27 | q.pop(); 28 | ahead->next = head; 29 | if (head->next != NULL) 30 | q.push(head->next); 31 | ahead = ahead->next; 32 | ahead->next = NULL; 33 | } 34 | return ans.next; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /230-kth-smallest-element-in-a-bst.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int kthSmallest(TreeNode* root, int k) { 13 | return findKthSmallest(root, k); 14 | } 15 | 16 | private : 17 | int findKthSmallest(TreeNode* root, int& k) { 18 | if (root == NULL) 19 | return 0; 20 | int ans = findKthSmallest(root->left, k); 21 | if (k == 0) 22 | return ans; 23 | if (--k == 0) 24 | return root->val; 25 | return findKthSmallest(root->right, k); 26 | } 27 | }; -------------------------------------------------------------------------------- /231-power-of-two.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPowerOfTwo(int n) { 4 | return n > 0 && (n & (n - 1)) == 0; 5 | } 6 | }; -------------------------------------------------------------------------------- /233-number-of-digit-one.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int countDigitOne(int n) { 4 | long long cnt = 0, base = 1; 5 | while (n / base >= 1) { 6 | long long cur = n % (base * 10) / base; 7 | long long higher = n / (base * 10); 8 | long long lower = n % base; 9 | if (cur < 1) { 10 | cnt += higher * base ; 11 | } else if (cur == 1) { 12 | cnt += higher * base + lower + 1; 13 | } else { 14 | cnt += (higher + 1) * base; 15 | } 16 | base *= 10; 17 | } 18 | return cnt; 19 | } 20 | }; -------------------------------------------------------------------------------- /235-lowest-common-ancestor-of-a-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { 13 | if (!root || !p || !q) 14 | return NULL; 15 | int val = root->val; 16 | if (min(p->val, q->val) > val) 17 | return lowestCommonAncestor(root->right, p, q); 18 | if (max(p->val, q->val) < val) 19 | return lowestCommonAncestor(root->left, p, q); 20 | return root; 21 | } 22 | }; -------------------------------------------------------------------------------- /239-sliding-window-maximum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector maxSlidingWindow(vector& nums, int k) { 4 | vector ans; 5 | deque deq; 6 | for (int i = 0; i < nums.size(); i++) { 7 | while (!deq.empty() && nums[deq.back()] <= nums[i]) 8 | deq.pop_back(); 9 | deq.push_back(i); 10 | while (!deq.empty() && deq.front() <= i - k) 11 | deq.pop_front(); 12 | if (i >= k - 1) 13 | ans.push_back(nums[deq.front()]); 14 | } 15 | return ans; 16 | } 17 | }; -------------------------------------------------------------------------------- /24-swap-nodes-in-pairs.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *swapPairs(ListNode *head) { 12 | ListNode ans = ListNode(0); 13 | ans.next = head; 14 | ListNode *p = &ans; 15 | while (p != NULL && p->next != NULL && p->next->next != NULL) { 16 | ListNode* q = p->next->next; 17 | p->next->next = q->next; 18 | q->next = p->next; 19 | p->next = q; 20 | p = p->next->next; 21 | } 22 | return ans.next; 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /240-search-a-2d-matrix-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool searchMatrix(vector>& matrix, int target) { 4 | int n = matrix.size(); 5 | if (n == 0) 6 | return 0; 7 | int m = matrix[0].size(); 8 | int row = 0, column = m - 1; 9 | while (row < n && column >= 0) { 10 | if (matrix[row][column] == target) { 11 | return true; 12 | } 13 | if (matrix[row][column] > target) { 14 | --column; 15 | } else { 16 | ++row; 17 | } 18 | } 19 | return false; 20 | } 21 | }; -------------------------------------------------------------------------------- /242-valid-anagram.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isAnagram(string s, string t) { 4 | if (s.size() != t.size()) 5 | return false; 6 | vector cnt(26, 0); 7 | for (int i = 0; i < s.size(); i++) { 8 | cnt[s[i] - 'a']++; 9 | cnt[t[i] - 'a']--; 10 | } 11 | for (int i : cnt) { 12 | if (i != 0) 13 | return false; 14 | } 15 | return true; 16 | } 17 | }; -------------------------------------------------------------------------------- /25-reverse-nodes-in-k-group.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *reverseKGroup(ListNode *head, int k) { 12 | ListNode ans = ListNode(0); 13 | ans.next = head; 14 | ListNode *pre = &ans, *now = head, *tail = &ans; 15 | int cnt = 0; 16 | while (now) { 17 | now = now->next; 18 | cnt++; 19 | } 20 | int tmp = cnt / k * k; 21 | cnt = 1; 22 | while (cnt <= tmp) { 23 | if (cnt % k == 1) { 24 | pre = tail; 25 | tail = head; 26 | } else { 27 | ListNode* t = head; 28 | tail->next = head->next; 29 | t->next = pre->next; 30 | pre->next = t; 31 | head = tail; 32 | } 33 | cnt++; 34 | head = head->next; 35 | } 36 | return ans.next; 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /257-binary-tree-paths.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector binaryTreePaths(TreeNode* root) { 13 | vector ans; 14 | findPath(root, "", ans); 15 | return ans; 16 | } 17 | 18 | private : 19 | void findPath(TreeNode* root, string path, vector &ans) { 20 | if (root == nullptr) 21 | return ; 22 | path += to_string(root->val); 23 | if (root->left == nullptr && root->right == nullptr) { 24 | ans.push_back(path); 25 | return ; 26 | } 27 | path += "->"; 28 | if (root->left) 29 | findPath(root->left, path, ans); 30 | if (root->right) 31 | findPath(root->right, path, ans); 32 | } 33 | }; -------------------------------------------------------------------------------- /258-add-digits.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int addDigits(int num) { 4 | return num == 0 ? 0 : num % 9 == 0 ? 9 : num % 9; 5 | } 6 | }; -------------------------------------------------------------------------------- /26-remove-duplicates-from-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeDuplicates(int A[], int n) { 4 | int a = 1, b = 0; 5 | if( n == 0 ) 6 | return 0; 7 | while( a < n ) { 8 | if( A[a++] != A[b] ) 9 | A[++b] = A[a-1]; 10 | } 11 | return b + 1; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /26-remove-duplicates-from-sorted-array_STL.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeDuplicates(int A[], int n) { 4 | return unique(A, A+n) - A; 5 | } 6 | }; 7 | -------------------------------------------------------------------------------- /260-single-number-iii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector singleNumber(vector& nums) { 4 | int xor_sum = 0; 5 | for (auto i : nums) 6 | xor_sum ^= i; 7 | int bit = xor_sum & (~(xor_sum - 1)); 8 | int a = xor_sum; 9 | for (auto k : nums) { 10 | if (k & bit) { 11 | a ^= k; 12 | } 13 | } 14 | return vector{a, a ^ xor_sum}; 15 | } 16 | }; -------------------------------------------------------------------------------- /263-ugly-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isUgly(int num) { 4 | if (num == 0) 5 | return false; 6 | for (int i = 2; i <= 5; i++) { 7 | while (num % i == 0) { 8 | num /= i; 9 | } 10 | } 11 | return num == 1; 12 | } 13 | }; -------------------------------------------------------------------------------- /264-ugly-number-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int nthUglyNumber(int n) { 4 | vector nums(n); 5 | int t2 = 0, t3 = 0, t5 = 0; 6 | nums[0] = 1; 7 | for (int i = 1; i < n; i++) { 8 | nums[i] = min(nums[t2] * 2, min(nums[t3] * 3, nums[t5] * 5)); 9 | if (nums[i] == nums[t2] * 2) 10 | t2++; 11 | if (nums[i] == nums[t3] * 3) 12 | t3++; 13 | if (nums[i] == nums[t5] * 5) 14 | t5++; 15 | } 16 | return nums.back(); 17 | } 18 | }; -------------------------------------------------------------------------------- /268-missing-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int missingNumber(vector& nums) { 4 | int n = nums.size(); 5 | int sum = accumulate(nums.begin(), nums.end(), 0); 6 | return n * (n + 1ll) / 2 - sum; 7 | } 8 | }; -------------------------------------------------------------------------------- /27-remove-element.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeElement(int A[], int n, int elem) { 4 | int pos = 0; 5 | for (int i = 0; i < n; i++) { 6 | if (A[i] != elem) { 7 | A[pos++] = A[i]; 8 | } 9 | } 10 | return pos; 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /273-integer-to-english-words.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string numberToWords(int num) { 4 | if (num == 0) 5 | return "Zero"; 6 | string ans; 7 | vector vans; 8 | for (int i = 0; i < number.size(); i++) { 9 | int now = num / number[i]; 10 | if (now != 0) { 11 | toString(now, vans); 12 | vans.push_back(name[i]); 13 | } 14 | num %= number[i]; 15 | } 16 | for (int i =0; i < vans.size(); i++) { 17 | if (vans[i] != "") { 18 | ans += ans == "" ? vans[i] : ' ' + vans[i]; 19 | } 20 | } 21 | return ans; 22 | } 23 | private : 24 | vector name = {"Billion", "Million", "Thousand", ""}; 25 | vector number = {1000000000, 1000000, 1000, 1}; 26 | vector small = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", 27 | "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"}; 28 | vector decade = {"", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"}; 29 | void toString(int num, vector &vans) { 30 | vans.push_back(Hundred(num / 100)); 31 | num %= 100; 32 | if (num != 0 && num < 20) { 33 | vans.push_back(small[num]); 34 | return ; 35 | } 36 | vans.push_back(decade[num / 10]); 37 | vans.push_back(small[num % 10]); 38 | } 39 | string Hundred(int num) { 40 | if (num == 0) 41 | return ""; 42 | return small[num] + " Hundred"; 43 | } 44 | }; -------------------------------------------------------------------------------- /274-h-index.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int hIndex(vector& citations) { 4 | int n = citations.size(); 5 | vector dp(n, 0); 6 | for (auto i : citations) { 7 | if (i == 0) 8 | continue; 9 | dp[min(i, n) - 1]++; 10 | } 11 | int sum = 0; 12 | for (int i = n - 1; i >= 0; i--) { 13 | sum += dp[i]; 14 | if (sum >= i + 1) { 15 | return i + 1; 16 | } 17 | } 18 | return 0; 19 | } 20 | }; -------------------------------------------------------------------------------- /278-first-bad-version.cpp: -------------------------------------------------------------------------------- 1 | // Forward declaration of isBadVersion API. 2 | bool isBadVersion(int version); 3 | 4 | class Solution { 5 | public: 6 | int firstBadVersion(int n) { 7 | int l = 1, r = n; 8 | while (l < r) { 9 | int mid = l + ((r - l) >> 1); 10 | if (isBadVersion(mid)) { 11 | r = mid; 12 | } else { 13 | l = mid + 1; 14 | } 15 | } 16 | return l; 17 | } 18 | }; -------------------------------------------------------------------------------- /279-perfect-squares.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numSquares(int n) { 4 | vector dp(n + 1, INT_MAX); 5 | dp[0] = 0; 6 | for (int i = 1; i <= n; i++) { 7 | for (int k = 1; k * k <= i; k++) { 8 | dp[i] = min(dp[i], dp[i - k * k] + 1); 9 | } 10 | } 11 | return dp[n]; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /28-implement-strstr.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int strStr(char *haystack, char *needle) { 4 | if (needle[0] == '\0') 5 | return 0; 6 | vector next = getNext(needle); 7 | int k = -1; 8 | for (int i = 0; haystack[i] != '\0'; i++) { 9 | while (k >= 0 && needle[k + 1] != haystack[i]) 10 | k = next[k]; 11 | if (needle[k + 1] == haystack[i]) { 12 | k++; 13 | if (needle[k + 1] == '\0') 14 | return i - k; 15 | } 16 | } 17 | return -1; 18 | } 19 | private : 20 | vector getNext(char *p) { 21 | vector next; 22 | next.push_back(-1); 23 | int k = -1; 24 | for (int i = 1; p[i] != '\0'; i++) { 25 | while (k >= 0 && p[k + 1] != p[i]) 26 | k = next[k]; 27 | if (p[k + 1] == p[i]) 28 | k++; 29 | next.push_back(k); 30 | } 31 | return next; 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /283-move-zeroes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void moveZeroes(vector& nums) { 4 | int l = 0; 5 | for (int i = 0; i < nums.size(); i++) { 6 | if (nums[i] != 0) { 7 | swap(nums[i], nums[l++]); 8 | } 9 | } 10 | } 11 | }; -------------------------------------------------------------------------------- /284-peeking-iterator.cpp: -------------------------------------------------------------------------------- 1 | // Below is the interface for Iterator, which is already defined for you. 2 | // **DO NOT** modify the interface for Iterator. 3 | class Iterator { 4 | struct Data; 5 | Data* data; 6 | public: 7 | Iterator(const vector& nums); 8 | Iterator(const Iterator& iter); 9 | virtual ~Iterator(); 10 | // Returns the next element in the iteration. 11 | int next(); 12 | // Returns true if the iteration has more elements. 13 | bool hasNext() const; 14 | }; 15 | 16 | 17 | class PeekingIterator : public Iterator { 18 | public: 19 | PeekingIterator(const vector& nums) : Iterator(nums) { 20 | // Initialize any member here. 21 | // **DO NOT** save a copy of nums and manipulate it directly. 22 | // You should only use the Iterator interface methods. 23 | peeked = false; 24 | } 25 | 26 | // Returns the next element in the iteration without advancing the iterator. 27 | int peek() { 28 | if (!peeked) { 29 | element = Iterator::next(); 30 | peeked = true; 31 | } 32 | return element; 33 | } 34 | 35 | // hasNext() and next() should behave the same as in the Iterator interface. 36 | // Override them if needed. 37 | int next() { 38 | if (!peeked) { 39 | element = Iterator::next(); 40 | } 41 | peeked = false; 42 | return element; 43 | } 44 | 45 | bool hasNext() const { 46 | return peeked || Iterator::hasNext(); 47 | } 48 | private : 49 | int element; 50 | bool peeked; 51 | }; 52 | -------------------------------------------------------------------------------- /29-divide-two-integers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int divide(int dividend, int divisor) { 4 | long long a = dividend; 5 | long long b = divisor; 6 | if (b == 0) 7 | return INT_MAX; 8 | if (b == 1) 9 | return (int)a; 10 | int flag = 1; 11 | if (a < 0) { 12 | flag *= -1; 13 | a *= -1; 14 | } 15 | if (b < 0) { 16 | flag *= -1; 17 | b *= -1; 18 | } 19 | int ans = 0; 20 | while (a >= b) { 21 | int i = 0; 22 | while (((long long)(b) << i) <= a) { 23 | i++; 24 | } 25 | ans += (1 << (i - 1)); 26 | a -= (b << (i - 1)); 27 | } 28 | if (ans * flag * 1ll * flag < 0) 29 | return INT_MAX; 30 | return ans * flag; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /290-word-pattern.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool wordPattern(string pattern, string str) { 4 | unordered_map umap; 5 | unordered_map strmap; 6 | int idx = 0; 7 | istringstream in(str); 8 | for (string sub; in >> sub; idx++) { 9 | if (idx == pattern.size() || umap[pattern[idx]] != strmap[sub]) 10 | return false; 11 | umap[pattern[idx]] = strmap[sub] = idx + 1; 12 | } 13 | return idx == pattern.size(); 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /292-nim-game.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool canWinNim(int n) { 4 | return n % 4 != 0; 5 | } 6 | }; 7 | -------------------------------------------------------------------------------- /3-Longest-Substring-Without-Repeating-Characters.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | const int N = 260; 4 | int lengthOfLongestSubstring(string s) { 5 | vector visit(N, -1); 6 | int cur_len = 0; 7 | int max_len = 0; 8 | for (int i = 0; i < s.size(); i++) { 9 | int ch = s[i]; 10 | if (visit[ch] == -1) { 11 | cur_len += 1; 12 | } else { 13 | cur_len = min(cur_len + 1, i - visit[ch]); 14 | } 15 | visit[ch] = i; 16 | max_len = max(cur_len, max_len); 17 | } 18 | return max_len; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /30-substring-with-concatenation-of-all-words.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector findSubstring(string s, vector& words) { 4 | int n = words.size(); 5 | unordered_map > umap; 6 | vector visit(s.size(), false); 7 | vector ans; 8 | int id = 0; 9 | for (int i = 0; i < words.size(); i++) { 10 | if (umap.count(words[i])) { 11 | umap[words[i]].second++; 12 | } else { 13 | umap[words[i]] = make_pair(id++, 1); 14 | } 15 | } 16 | int one_len = words[0].size(); 17 | int all_len = one_len * words.size(); 18 | for (int i = 0; i <= (int)s.size() - all_len; i++) { 19 | if (visit[i]) 20 | continue; 21 | int pos = i, sum = 0; 22 | vector cnt(umap.size(), 0); 23 | while(1) { 24 | while (pos + (n - sum) * one_len <= s.size() && check(s.substr(pos, one_len), cnt, umap)) { 25 | pos += one_len; 26 | sum++; 27 | } 28 | visit[pos - sum * one_len] = true; 29 | if (sum == n) 30 | ans.push_back(pos - all_len); 31 | if (sum <= 1) 32 | break; 33 | cnt[umap[s.substr(pos - sum * one_len, one_len)].first]--; 34 | sum--; 35 | } 36 | } 37 | return ans; 38 | } 39 | private : 40 | bool check(string sub, vector &cnt, unordered_map >& umap) { 41 | if (umap.count(sub)) { 42 | if (umap[sub].second > cnt[umap[sub].first]) { 43 | cnt[umap[sub].first]++; 44 | return true; 45 | } 46 | } 47 | return false; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /31-next-permutation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void nextPermutation(vector &next) { 4 | int pos = 0, n = next.size(); 5 | for (int i = n - 1; i > 0; i--) { 6 | if (next[i - 1] < next[i]) { 7 | pos = lower_bound(next.begin() + i, next.end(), next[i - 1], greater()) - next.begin() - 1; 8 | swap(next[pos], next[i - 1]); 9 | pos = i; 10 | break; 11 | } 12 | } 13 | reverse(next.begin() + pos, next.end()); 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /32-substring-with-concatenation-of-all-words.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int longestValidParentheses(string s) { 4 | int ans = 0; 5 | stack stk; 6 | for (int i = 0; i < s.size(); i++) { 7 | if (s[i] == '(') { 8 | stk.push(i); 9 | } else { 10 | if (!stk.empty() && s[stk.top()] == '(') { 11 | stk.pop(); 12 | if (stk.empty()) 13 | ans = i + 1; 14 | else 15 | ans = max(ans, i - stk.top()); 16 | } else { 17 | stk.push(i); 18 | } 19 | } 20 | } 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /33-search-in-rotated-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int bsearch_find_pivot(int a[], int n) { 4 | int l = 0, r = n - 1; 5 | while (l < r) { 6 | int mid = (l + r) >> 1; 7 | if (a[mid] < a[0]) { 8 | r = mid; 9 | } else { 10 | l = mid + 1; 11 | } 12 | } 13 | return l; 14 | } 15 | int search(int A[], int n, int target) { 16 | int pivot = bsearch_find_pivot(A, n); 17 | int s = pivot, t = pivot; 18 | if (target <= A[n-1]) 19 | t = n; 20 | if (target >= A[0]) 21 | s = 0; 22 | int pos = lower_bound(A + s, A + t, target) - A; 23 | if (pos < n && A[pos] == target) 24 | return pos; 25 | return -1; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /34-search-for-a-range-STL.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector searchRange(int A[], int n, int target) { 4 | int a = lower_bound(A, A + n, target) - A; 5 | if (A[a] != target) 6 | return vector{-1, -1}; 7 | int b = upper_bound(A, A + n, target) - A - 1; 8 | return vector{a, b}; 9 | } 10 | }; 11 | -------------------------------------------------------------------------------- /34-search-for-a-range.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int find_lower(int a[], int n, int target) { 4 | int l = 0, r = n - 1; 5 | while (l < r) { 6 | int mid = (l + r) / 2; 7 | if (target <= a[mid]) 8 | r = mid; 9 | else 10 | l = mid + 1; 11 | } 12 | if (a[l] != target) 13 | return -1; 14 | return l; 15 | } 16 | int find_upper(int a[], int n, int target) { 17 | int l = 0, r = n - 1; 18 | while (l <= r) { 19 | int mid = (l + r) / 2; 20 | if (target >= a[mid]) 21 | l = mid + 1; 22 | else 23 | r = mid - 1; 24 | } 25 | return l - 1; 26 | } 27 | vector searchRange(int A[], int n, int target) { 28 | int a = find_lower(A, n, target); 29 | if (a == -1) 30 | return vector{-1, -1}; 31 | int b = find_upper(A, n, target); 32 | return vector{a, b}; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /35-search-insert-position.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int searchInsert(int A[], int n, int target) { 4 | int pos = upper_bound(A, A + n, target) - A; 5 | if (pos != 0 && A[pos - 1] == target) 6 | return pos - 1; 7 | return pos; 8 | } 9 | }; 10 | -------------------------------------------------------------------------------- /36-valid-sudoku.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | const int MAX = 10; 4 | bool isValidSudoku(vector > &board) { 5 | bool used_r[MAX][MAX]; 6 | bool used_c[MAX][MAX]; 7 | bool used_9[MAX][MAX]; 8 | memset(used_r, 0, sizeof(used_r)); 9 | memset(used_c, 0, sizeof(used_c)); 10 | memset(used_9, 0, sizeof(used_9)); 11 | 12 | for (int i = 0; i < board.size(); i++) { 13 | for (int k = 0; k < board[i].size(); k++) { 14 | char ch = board[i][k]; 15 | if (ch == '.') 16 | continue; 17 | int id = i / 3 * 3 + k / 3; 18 | int n = ch - '0'; 19 | if (!used_r[i][n] && !used_c[k][n] && !used_9[id][n]) { 20 | used_r[i][n] = used_c[k][n] = used_9[id][n] = true; 21 | } else { 22 | return false; 23 | } 24 | } 25 | } 26 | return true; 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /37-sudoku-solver.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | 4 | void solveSudoku(vector > &board) { 5 | memset(used_r, 0, sizeof(used_r)); 6 | memset(used_c, 0, sizeof(used_c)); 7 | memset(used_9, 0, sizeof(used_9)); 8 | for (int i = 0; i < 9; i++) { 9 | for (int k = 0; k < 9; k++) { 10 | if (board[i][k] != '.') { 11 | int x = board[i][k] - '0'; 12 | used_r[i][x] = used_c[k][x] = used_9[i / 3 * 3 + k / 3][x] = true; 13 | } 14 | } 15 | } 16 | dfs(board); 17 | } 18 | 19 | private: 20 | static const int MAX = 10; 21 | bool used_r[MAX][MAX]; 22 | bool used_c[MAX][MAX]; 23 | bool used_9[MAX][MAX]; 24 | bool check(int x, int y, int k) { 25 | return !used_r[x][k] && !used_c[y][k] && !used_9[x / 3 * 3 + y / 3][k]; 26 | } 27 | bool dfs(vector > &board) { 28 | bool flag = false; 29 | for (int i = 0; i < MAX - 1; i++) { 30 | for (int k = 0; k < MAX - 1; k++) { 31 | if (board[i][k] == '.') { 32 | flag = true; 33 | for (int id = 1; id < MAX; id++) { 34 | if (check(i, k, id)) { 35 | int x = i / 3 * 3 + k / 3; 36 | used_r[i][id] = used_c[k][id] = used_9[x][id] = true; 37 | board[i][k] = '0' + id; 38 | if (dfs(board)) 39 | return true; 40 | board[i][k] = '.'; 41 | used_r[i][id] = used_c[k][id] = used_9[x][id] = false; 42 | } 43 | } 44 | if (board[i][k] == '.') 45 | return false; 46 | } 47 | } 48 | } 49 | return true; 50 | } 51 | }; 52 | -------------------------------------------------------------------------------- /38-count-and-say.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string countAndSay(int n) { 4 | string s = "1"; 5 | for (int i = 0; i < n - 1; i++) 6 | s = say(s); 7 | return s; 8 | } 9 | 10 | private : 11 | string say(string s) { 12 | ostringstream oss; 13 | int cnt = 1, n = s.size(); 14 | for (int i = 1; i <= n; i++) { 15 | if (i == n || s[i] != s[i - 1]) { 16 | oss << cnt << s[i - 1]; 17 | cnt = 1; 18 | } else { 19 | ++cnt; 20 | } 21 | } 22 | return oss.str(); 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /39-combination-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > combinationSum(vector &candidates, int target) { 4 | vector > ans; 5 | vector v; 6 | sort(candidates.begin(), candidates.end()); 7 | dfs(0, target, v, candidates, ans); 8 | return ans; 9 | } 10 | 11 | private : 12 | void dfs(int x, int target, vector &v, vector &candidates, vector > &ans) { 13 | if (target == 0) { 14 | ans.push_back(v); 15 | return ; 16 | } 17 | for (int i = x; i < candidates.size(); i++) { 18 | if (target < candidates[i]) 19 | return ; 20 | v.push_back(candidates[i]); 21 | dfs(i, target - candidates[i], v, candidates, ans); 22 | v.pop_back(); 23 | } 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /4-median-of-two-sorted-arrays.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findK(int a[], int na, int b[], int nb, int k) { 4 | if (na == 0) 5 | return b[k - 1]; 6 | if (nb == 0) 7 | return a[k - 1]; 8 | if (k == 1) 9 | return min(a[0], b[0]); 10 | int k1, k2; 11 | if (na < nb) { 12 | k1 = min(na, k / 2); 13 | k2 = k - k1; 14 | } else { 15 | k2 = min(nb, k / 2); 16 | k1 = k - k2; 17 | } 18 | if (a[k1 - 1] < b[k2 - 1]) { 19 | return findK(a + k1, na - k1, b, k2, k - k1); 20 | } else if (a[k1 - 1] > b[k2 - 1]){ 21 | return findK(a, k1, b + k2, nb - k2, k - k2); 22 | } else { 23 | return a[k1 - 1]; 24 | } 25 | } 26 | double findMedianSortedArrays(int A[], int m, int B[], int n) { 27 | if ((m + n) % 2 == 1) { 28 | int k = (m + n + 1) / 2; 29 | return findK(A, m, B, n, k); 30 | } else { 31 | int k = (m + n) / 2; 32 | return (findK(A, m, B, n, k) + findK(A, m, B, n, k + 1)) / 2.0; 33 | } 34 | } 35 | }; 36 | -------------------------------------------------------------------------------- /40-combination-sum-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > combinationSum2(vector &num, int target) { 4 | vector > ans; 5 | vector v; 6 | sort(num.begin(), num.end()); 7 | dfs(0, target, v, num, ans); 8 | return ans; 9 | } 10 | 11 | private : 12 | void dfs(int x, int target, vector &v, vector &num, vector > &ans) { 13 | if (target == 0) { 14 | ans.push_back(v); 15 | return ; 16 | } 17 | for (int i = x; i < num.size(); i++) { 18 | if (target < num[i]) 19 | return ; 20 | if (i != x && num[i - 1] == num[i]) 21 | continue; 22 | v.push_back(num[i]); 23 | dfs(i + 1, target - num[i], v, num, ans); 24 | v.pop_back(); 25 | } 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /41-first-missing-positive.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int firstMissingPositive(int A[], int n) { 4 | for (int i = 0; i < n; i++) { 5 | while (A[i] - 1 >= 0 && A[i] - 1 < i && A[A[i] - 1] != A[i]) 6 | swap(A[i], A[A[i] - 1]); 7 | } 8 | for (int i = 0; i < n; i++) { 9 | if (A[i] != i + 1) 10 | return i + 1; 11 | } 12 | return n + 1; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /42-trapping-rain-water.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int trap(vector& height) { 4 | int n = height.size(); 5 | int lmax = 0, rmax = 0, sum = 0, l = 0, r = n - 1; 6 | while (l <= r) { 7 | lmax = max(lmax, height[l]); 8 | rmax = max(rmax, height[r]); 9 | if (lmax < rmax) { 10 | sum += (lmax - height[l++]); 11 | } else { 12 | sum += (rmax - height[r--]); 13 | } 14 | } 15 | return sum; 16 | } 17 | }; -------------------------------------------------------------------------------- /43-multiply-strings.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string multiply(string num1, string num2) { 4 | if (num1 == "0" || num2 == "0") 5 | return "0"; 6 | vector ans(num1.size() + num2.size(), 0); 7 | for (int i = num1.size() - 1; i >= 0; i--) { 8 | for (int k = num2.size() - 1; k >= 0; k--) { 9 | int pos = num1.size() - 1 - i + num2.size() - 1 - k; 10 | ans[pos] += (num1[i] - '0') * (num2[k] - '0'); 11 | ans[pos + 1] += ans[pos] / 10; 12 | ans[pos] %= 10; 13 | } 14 | } 15 | int i = ans.size() - 1; 16 | while (ans[i] == 0) 17 | i--; 18 | ans.resize(i + 1); 19 | return vec2str(ans); 20 | } 21 | 22 | private : 23 | string vec2str(vector a) { 24 | string s; 25 | for (int i = a.size() - 1; i >= 0; i--) { 26 | s += char('0' + a[i]); 27 | } 28 | return s; 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /45-jump-game-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int jump(int A[], int n) { 4 | int far = 0; 5 | int now = 0; 6 | int ans = 0; 7 | for (int i = 0; i < n; i++) { 8 | if (i > far) { 9 | far = now; 10 | ans++; 11 | } 12 | now = max(now, i + A[i]); 13 | } 14 | return ans; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /46-permutations.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > ans; 4 | static const int MAX = 101; 5 | int now[MAX]; 6 | bool used[MAX]; 7 | int cnt; 8 | void dfs(vector &num, int step, int n) { 9 | if (step == n) { 10 | ans.push_back(vector(now, now + n)); 11 | return ; 12 | } 13 | for (int i=0; i > permute(vector &num) { 23 | memset(used, 0, sizeof(used)); 24 | dfs(num, 0, num.size()); 25 | return ans; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /47-permutations-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > permuteUnique(vector &num) { 4 | vector > ans; 5 | vector used(num.size(), 0); 6 | vector v; 7 | sort(num.begin(), num.end()); 8 | dfs(v, used, num, ans); 9 | return ans; 10 | } 11 | 12 | private : 13 | void dfs(vector &v, vector &used, vector &num, vector > &ans) { 14 | if (v.size() == num.size()) { 15 | ans.push_back(v); 16 | return ; 17 | } 18 | for (int i = 0; i < num.size(); i++) { 19 | if (used[i] || i != 0 && num[i] == num[i - 1] && !used[i - 1]) 20 | continue; 21 | used[i] = true; 22 | v.push_back(num[i]); 23 | dfs(v, used, num, ans); 24 | v.pop_back(); 25 | used[i] = false; 26 | } 27 | } 28 | }; 29 | 30 | -------------------------------------------------------------------------------- /48-rotate-image.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void rotate(vector > &matrix) { 4 | int n = matrix.size(); 5 | for (int i = 0; i < n / 2; i++) { 6 | for (int k = i; k < n - i - 1; k++) { 7 | int tmp = matrix[i][k]; 8 | int ti = i, tk = k; 9 | for (int j = 0; j < 4; j++) { 10 | swap(matrix[tk][n - ti - 1], tmp); 11 | swap(ti, tk); 12 | tk = n - tk - 1; 13 | } 14 | } 15 | } 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /49-anagrams.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector anagrams(vector &strs) { 4 | vector ans; 5 | unordered_map m; 6 | int n = strs.size(); 7 | for (int i = 0; i < n; i++) { 8 | string key = strs[i]; 9 | sort(key.begin(), key.end()); 10 | if (m.count(key)) { 11 | ans.push_back(strs[i]); 12 | int pos = m[key]; 13 | if (pos != -1) { 14 | ans.push_back(strs[pos]); 15 | m[key] = -1; 16 | } 17 | } else { 18 | m[key] = i; 19 | } 20 | } 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /5-longest-palindromic-substring.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string longestPalindrome(string s) { 4 | int mx = 0, id = 0, ans = 0, pos = 0; 5 | string ss = "$#"; 6 | for (int i = 0; i < s.size(); i++) { 7 | ss += s[i]; 8 | ss += '#'; 9 | } 10 | vector dp(ss.size(), 0); 11 | for (int i = 1; i < ss.size(); i++) { 12 | if (mx > i) { 13 | dp[i] = min(dp[2 * id - i], mx - i); 14 | } else { 15 | dp[i] = 1; 16 | } 17 | 18 | while (ss[i + dp[i]] == ss[i - dp[i]]) 19 | dp[i]++; 20 | if (i + dp[i] > mx) { 21 | mx = i + dp[i]; 22 | id = i; 23 | } 24 | if (dp[i] > ans) { 25 | ans = dp[i]; 26 | pos = i; 27 | } 28 | } 29 | return s.substr((pos - ans) / 2, ans - 1); 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /50-powx-n.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | double pow(double x, int n) { 4 | bool flag = n > 0; 5 | long long nn = abs((long long)(n)); 6 | double p = x; 7 | double ans = 1; 8 | while(nn) { 9 | if (nn & 1) 10 | ans *= p; 11 | p = p * p; 12 | nn >>= 1; 13 | } 14 | return flag ? ans : 1 / ans; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /51-n-queens.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > solveNQueens(int n) { 4 | vector > ans; 5 | vector state(n, string(n, '.')); 6 | int column = 0, ld = 0, rd = 0; 7 | dfs(0, state, column, ld, rd, ans); 8 | return ans; 9 | } 10 | 11 | private : 12 | void dfs(int x, vector &state, int column, int ld, int rd, vector > &ans) { 13 | if (x == state.size()) { 14 | ans.push_back(state); 15 | return ; 16 | } 17 | for (int i = 0; i < state.size(); i++) { 18 | int id = x + i; 19 | int id2 = state.size() - x - 1 + i; 20 | if ((column & (1 << i)) == 0 && (ld & (1 << id)) == 0 && (rd & (1 << id2)) == 0) { 21 | state[x][i] = 'Q'; 22 | dfs(x + 1, state, column | (1 << i), ld | (1 << id), rd | (1 << id2), ans); 23 | state[x][i] = '.'; 24 | } 25 | } 26 | } 27 | }; 28 | 29 | -------------------------------------------------------------------------------- /52-n-queens-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int totalNQueens(int n) { 4 | int ans = 0; 5 | int column = 0, ld = 0, rd = 0; 6 | dfs(0, column, ld, rd, ans, n); 7 | return ans; 8 | } 9 | 10 | private : 11 | void dfs(int x, int column, int ld, int rd, int &ans, int n) { 12 | if (x == n) { 13 | ++ans; 14 | return ; 15 | } 16 | for (int i = 0; i < n; i++) { 17 | int id = x + i; 18 | int id2 = n - x - 1 + i; 19 | if ((column & (1 << i)) == 0 && (ld & (1 << id)) == 0 && (rd & (1 << id2)) == 0) { 20 | dfs(x + 1, column | (1 << i), ld | (1 << id), rd | (1 << id2), ans, n); 21 | } 22 | } 23 | } 24 | }; 25 | 26 | -------------------------------------------------------------------------------- /53-maximum-subarray.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxSubArray(int A[], int n) { 4 | int sum = 0, ans = A[0]; 5 | for (int i = 0; i < n; i++) { 6 | sum += A[i]; 7 | ans = max(sum, ans); 8 | sum = sum < 0 ? 0 : sum; 9 | } 10 | return ans; 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /54-spiral-matrix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector spiralOrder(vector > &matrix) { 4 | vector ans; 5 | int m = matrix.size(); 6 | if (m == 0) 7 | return ans; 8 | int cnt = 0, n = matrix[0].size(); 9 | while (cnt < (min(m, n) + 1) / 2) { 10 | for (int k = cnt; k <= n - cnt - 1; k++) 11 | ans.push_back(matrix[cnt][k]); 12 | 13 | for (int i = cnt + 1; i <= m - cnt - 1 && n - cnt - 1 >= cnt; i++) 14 | ans.push_back(matrix[i][n - cnt - 1]); 15 | 16 | for (int k = n - cnt - 2; k >= cnt && m - cnt - 1 > cnt; k--) 17 | ans.push_back(matrix[m - cnt - 1][k]); 18 | 19 | for (int i = m - cnt - 2; i > cnt && cnt < n - cnt - 1; i--) 20 | ans.push_back(matrix[i][cnt]); 21 | cnt++; 22 | } 23 | return ans; 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /55-jump-game.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool canJump(int A[], int n) { 4 | int far = 0; 5 | for (int i = 0; i < n; i++) { 6 | if (far < i) 7 | break; 8 | far = max(A[i] + i, far); 9 | } 10 | return far >= n - 1; 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /56-merge-intervals.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for an interval. 3 | * struct Interval { 4 | * int start; 5 | * int end; 6 | * Interval() : start(0), end(0) {} 7 | * Interval(int s, int e) : start(s), end(e) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | class cmp { 13 | public: 14 | bool operator()(Interval a, Interval b) { 15 | return a.start < b.start; 16 | } 17 | }; 18 | vector merge(vector &intervals) { 19 | int n = intervals.size(); 20 | vector ans; 21 | if (n == 0) 22 | return ans; 23 | sort(intervals.begin(), intervals.end(), cmp()); 24 | ans.push_back(intervals[0]); 25 | for (int i = 1; i < n; i++) { 26 | if (intervals[i].start > ans.back().end) { 27 | ans.push_back(intervals[i]); 28 | } else { 29 | ans.back().end = max(ans.back().end, intervals[i].end); 30 | } 31 | } 32 | return ans; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /57-insert-interval.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for an interval. 3 | * struct Interval { 4 | * int start; 5 | * int end; 6 | * Interval() : start(0), end(0) {} 7 | * Interval(int s, int e) : start(s), end(e) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector insert(vector &intervals, Interval newInterval) { 13 | int start = newInterval.start, end = newInterval.end; 14 | vector ans; 15 | int i; 16 | for (i = 0; i < intervals.size(); i++) { 17 | if (intervals[i].end < start) 18 | ans.push_back(intervals[i]); 19 | if (intervals[i].start > end) 20 | break; 21 | if (intervals[i].start >= start && intervals[i].start <= end || intervals[i].end <= end && intervals[i].end >= start 22 | || start >= intervals[i].start && start <= intervals[i].end) { 23 | start = min(start, intervals[i].start); 24 | end = max(end, intervals[i].end); 25 | } 26 | } 27 | ans.push_back(Interval(start, end)); 28 | for (; i < intervals.size(); i++) 29 | ans.push_back(intervals[i]); 30 | return ans; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /58-length-of-last-word.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int lengthOfLastWord(string s) { 4 | int n = s.size() - 1; 5 | while (n >= 0 && s[n] == ' ') 6 | n--; 7 | int cnt = 0; 8 | while (n >= 0 && s[n] != ' ') { 9 | cnt++; 10 | n--; 11 | } 12 | return cnt; 13 | } 14 | }; -------------------------------------------------------------------------------- /59-spiral-matrix-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > generateMatrix(int n) { 4 | vector > ans(n, vector(n, 0)); 5 | int i = 0, k = -1, id = 1; 6 | while (id <= n * n) { 7 | while (k + 1 < n && ans[i][k + 1] == 0) { 8 | ans[i][++k] = id++; 9 | } 10 | while (i + 1 < n && ans[i + 1][k] == 0) { 11 | ans[++i][k] = id++; 12 | } 13 | while (k - 1 >= 0 && ans[i][k - 1] == 0) { 14 | ans[i][--k] = id++; 15 | } 16 | while (i - 1 >= 0 && ans[i - 1][k] == 0) { 17 | ans[--i][k] = id++; 18 | } 19 | } 20 | return ans; 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /6-zigzag-conversion.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string convert(string s, int nRows) { 4 | int length = s.size(); 5 | if (length == 0 || nRows == 1) 6 | return s; 7 | string ans = ""; 8 | int step = nRows * 2 - 2; 9 | int b = 2; 10 | for (int i=0; i f(n, 1); 6 | vector id(n + 1, 0); 7 | for (int i = 0; i < n; i++) 8 | id[i] = i + 1; 9 | for (int i = 2; i < n; i++) 10 | f[i] = f[i - 1] * i; 11 | k--; 12 | for (int i = n - 1; i >= 0; i--) { 13 | ans += char('0' + id[k / f[i]]); 14 | id.erase(id.begin() + k / f[i]); 15 | k %= f[i]; 16 | } 17 | return ans; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /61-rotate-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *rotateRight(ListNode *head, int k) { 12 | if (head == NULL || k == 0) 13 | return head; 14 | ListNode ans = ListNode(0); 15 | ans.next = head; 16 | int len = 1; 17 | while (head->next) { 18 | head = head->next; 19 | len++; 20 | } 21 | k = k % len; 22 | head->next = ans.next; 23 | for (int i = 0; i < len - k; i++) { 24 | head = head->next; 25 | } 26 | ans.next = head->next; 27 | head->next = NULL; 28 | return ans.next; 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /62-unique-paths.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int uniquePaths(int m, int n) { 4 | vector > dp(m, vector(n)); 5 | for (int i = 0; i < n; i++) 6 | dp[0][i] = 1; 7 | for (int i = 0; i < m; i++) 8 | dp[i][0] = 1; 9 | 10 | for (int i = 1; i < m; i++) { 11 | for (int k = 1; k < n; k++) { 12 | dp[i][k] = dp[i - 1][k] + dp[i][k - 1]; 13 | } 14 | } 15 | return dp[m - 1][n - 1]; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /63-unique-paths-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int uniquePathsWithObstacles(vector > &obstacleGrid) { 4 | int n = obstacleGrid.size(); 5 | if (n == 0) 6 | return 0; 7 | int m = obstacleGrid[0].size(); 8 | vector > dp(n, vector(m, 0)); 9 | for (int i = 0; i < m && obstacleGrid[0][i] != 1; i++) { 10 | dp[0][i] = 1; 11 | } 12 | for (int i = 0; i < n && obstacleGrid[i][0] != 1; i++) { 13 | dp[i][0] = 1; 14 | } 15 | for (int i = 1; i < n; i++) { 16 | for (int k = 1; k < m; k++) { 17 | if (obstacleGrid[i][k] == 0) { 18 | dp[i][k] = dp[i - 1][k] + dp[i][k - 1]; 19 | } 20 | } 21 | } 22 | return dp.back().back(); 23 | } 24 | }; -------------------------------------------------------------------------------- /64-minimum-path-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minPathSum(vector > &grid) { 4 | int m = grid.size(); 5 | if (m == 0) 6 | return 0; 7 | int n = grid[0].size(); 8 | vector dp(n, 0); 9 | dp[0] = grid[0][0]; 10 | 11 | for (int i = 1; i < n; i++) 12 | dp[i] = dp[i - 1] + grid[0][i]; 13 | 14 | for (int i = 1; i < m; i++) { 15 | dp[0] = dp[0] + grid[i][0]; 16 | for (int k = 1; k < n; k++) { 17 | dp[k] = min(dp[k - 1], dp[k]) + grid[i][k]; 18 | } 19 | } 20 | return dp[n - 1]; 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /66-plus-one.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector plusOne(vector &digits) { 4 | int add = 1; 5 | for (int i = digits.size() - 1; i >= 0; i--) { 6 | digits[i] += add; 7 | add = digits[i] / 10; 8 | digits[i] %= 10; 9 | if (add == 0) 10 | break; 11 | } 12 | if (add) 13 | digits.insert(digits.begin(), add); 14 | return digits; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /67-add-binary.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string addBinary(string a, string b) { 4 | ostringstream oss; 5 | int i = a.size() - 1, k = b.size() - 1; 6 | int carry = 0; 7 | while (i >= 0 || k >= 0) { 8 | int num = carry; 9 | if (i >= 0) 10 | num += a[i--] - '0'; 11 | if (k >= 0) 12 | num += b[k--] - '0'; 13 | carry = num / 2; 14 | num %= 2; 15 | oss << char(num + '0'); 16 | } 17 | if (carry) 18 | oss << '1'; 19 | string ans = oss.str(); 20 | reverse(ans.begin(), ans.end()); 21 | return ans; 22 | } 23 | }; -------------------------------------------------------------------------------- /68-text-justification.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector fullJustify(vector& words, int maxWidth) { 4 | vector now; 5 | vector ans; 6 | int len = 0; 7 | for (int i = 0; i <= words.size(); i++) { 8 | if (i == words.size() || len + now.size() + words[i].size() > maxWidth) { 9 | string s; 10 | if (now.size() == 1 || i == words.size()) { 11 | for (int k = 0; k < now.size(); k++) { 12 | s += now[k]; 13 | if (k != now.size() - 1) 14 | s += ' '; 15 | } 16 | s += space(maxWidth - (len + now.size() - 1)); 17 | } else { 18 | int base = (maxWidth - len) / (now.size() - 1); 19 | int lastSpace = (maxWidth - len) % (now.size() - 1); 20 | for (int k = 0; k < now.size(); k++) { 21 | s += now[k]; 22 | if (k != now.size() - 1) { 23 | s += space(base + (lastSpace > 0 ? 1 : 0)); 24 | lastSpace--; 25 | } 26 | } 27 | } 28 | ans.push_back(s); 29 | if (i == words.size()) 30 | break; 31 | len = words[i].size(); 32 | now.clear(); 33 | now.push_back(words[i]); 34 | } else { 35 | now.push_back(words[i]); 36 | len += words[i].size(); 37 | } 38 | } 39 | return ans; 40 | } 41 | 42 | private : 43 | string space(int x) { 44 | string s; 45 | for (int i = 0; i < x; i++) 46 | s += ' '; 47 | return s; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /69-sqrtx.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int sqrt(int x) { 4 | int l = 0, r = x; 5 | while (l < r) { 6 | int mid = (l + r) >> 1; 7 | if (mid * 1ll * mid > x) 8 | r = mid; 9 | else 10 | l = mid + 1; 11 | } 12 | if (l * 1ll * l > x) 13 | l--; 14 | return l; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /7-reverse-integer.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int reverse(int x) { 4 | if( x == 0 ) 5 | return 0; 6 | int flag = x / abs(x); 7 | int ans = 0; 8 | x = abs(x); 9 | while( x ) { 10 | if( (ans * 10) / 10 != ans ) 11 | return 0; 12 | ans *= 10; 13 | if( (ans + (x % 10)) - (x % 10) != ans ) 14 | return 0; 15 | ans += x % 10; 16 | x /= 10; 17 | } 18 | return ans * flag; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /70-climbing-stairs.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int climbStairs(int n) { 4 | vector dp(n + 1, 0); 5 | dp[1] = dp[0] = 1; 6 | for (int i = 2; i <= n; i++) { 7 | dp[i] = dp[i - 1] + dp[i - 2]; 8 | } 9 | return dp[n]; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /71-simplify-path.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string simplifyPath(string path) { 4 | vector dir; 5 | int pos = 0; 6 | while (pos < path.size()) { 7 | int t = path.find("/", pos + 1); 8 | if (t == -1) { 9 | t = path.size(); 10 | } 11 | string str = path.substr(pos + 1, t - pos - 1); 12 | pos = t; 13 | if (str == "" || str == ".") 14 | continue; 15 | if (str == "..") { 16 | if (!dir.empty()) 17 | dir.pop_back(); 18 | continue; 19 | } 20 | dir.push_back(str); 21 | } 22 | if (dir.empty()) 23 | return "/"; 24 | string rst = ""; 25 | for (int i = 0; i < dir.size(); i++) 26 | rst += "/" + dir[i]; 27 | return rst; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /72-edit-distance.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minDistance(string word1, string word2) { 4 | word1 = '#' + word1; 5 | word2 = '#' + word2; 6 | int n = word1.size(); 7 | int m = word2.size(); 8 | vector > dp(n, vector(m, 0)); 9 | for (int i = 0; i < m; i++) 10 | dp[0][i] = i; 11 | 12 | for (int i = 0; i < n; i++) 13 | dp[i][0] = i; 14 | 15 | for (int i = 1; i < n; i++) { 16 | for (int k = 1; k < m; k++) { 17 | if (word1[i] == word2[k]) 18 | dp[i][k] = dp[i - 1][k - 1]; 19 | else 20 | dp[i][k] = min(dp[i - 1][k - 1], min(dp[i - 1][k], dp[i][k - 1])) + 1; 21 | } 22 | } 23 | return dp[n - 1][m - 1]; 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /73-set-matrix-zeroes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void setZeroes(vector > &matrix) { 4 | int m = matrix.size(); 5 | if (m == 0) 6 | return ; 7 | int n = matrix[0].size(); 8 | bool row = false, col = false; 9 | for (int i = 0; i < n && !row; i++) 10 | if (matrix[0][i] == 0) 11 | row = true; 12 | 13 | for (int i = 0; i < m && !col; i++) 14 | if (matrix[i][0] == 0) 15 | col = true; 16 | 17 | for (int i = 1; i < m; i++) { 18 | for (int k = 1; k < n; k++) 19 | if (matrix[i][k] == 0) { 20 | matrix[i][0] = matrix[0][k] = 0; 21 | } 22 | } 23 | for (int i = 1; i < m; i++) { 24 | for (int k = 1; k < n; k++) { 25 | if (matrix[i][0] == 0 || matrix[0][k] == 0) 26 | matrix[i][k] = 0; 27 | } 28 | } 29 | 30 | if (row) { 31 | fill(matrix[0].begin(), matrix[0].end(), 0); 32 | } 33 | if (col) { 34 | for (int i = 0; i < m; i++) 35 | matrix[i][0] = 0; 36 | } 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /74-search-a-2d-matrix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool searchMatrix(vector > &matrix, int target) { 4 | int n = matrix.size(), m = matrix[0].size(); 5 | int pos = binarySearch(matrix, target); 6 | if (pos - 1 < 0) 7 | return false; 8 | return binary_search(matrix[pos - 1].begin(), matrix[pos - 1].end(), target); 9 | } 10 | 11 | private: 12 | int binarySearch(vector > &matrix, int target) { 13 | int l = 0, r = matrix.size() - 1; 14 | while (l <= r) { 15 | int mid = (l + r) >> 1; 16 | if (matrix[mid][0] <= target) 17 | l = mid + 1; 18 | else 19 | r = mid - 1; 20 | } 21 | return l; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /75-sort-colors.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void sortColors(int A[], int n) { 4 | int l = 0, r = n - 1; 5 | for (int i = 0; i <= r;) { 6 | if (A[i] == 0) 7 | swap(A[i++], A[l++]); 8 | else if (A[i] == 2) 9 | swap(A[i], A[r--]); 10 | else 11 | i++; 12 | } 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /76-minimum-window-substring.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string minWindow(string S, string T) { 4 | const int MAX = 260; 5 | queue q; 6 | vector pos(MAX, 0); 7 | vector cnt(MAX, 0); 8 | int len = INT_MAX, p = -1; 9 | int c = 0; 10 | for (int i = 0; i < T.size(); i++) 11 | cnt[T[i]]++; 12 | vector red = cnt; 13 | for (int i = 0; i < S.size(); i++) { 14 | int id = S[i]; 15 | if (cnt[id] == 0) 16 | continue; 17 | pos[id] = i; 18 | red[id]--; 19 | if (red[id] >= 0) 20 | c++; 21 | q.push(i); 22 | while (!q.empty() && pos[S[q.front()]] > q.front() && red[S[q.front()]] < 0) { 23 | int k = S[q.front()]; 24 | red[k]++; 25 | if (red[k] > 0) 26 | c--; 27 | q.pop(); 28 | } 29 | if (c == T.size() && len > i - q.front()) { 30 | len = i - q.front(); 31 | p = q.front(); 32 | } 33 | } 34 | return len == INT_MAX ? "" : S.substr(p, len + 1); 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /77-combinations.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > combine(int n, int k) { 4 | vector > ans; 5 | if (k > n) 6 | return ans; 7 | vector nums; 8 | dfs(1, k, n, ans, nums); 9 | return ans; 10 | } 11 | 12 | private : 13 | void dfs(int x, int k, int n, vector > &ans, vector &nums) { 14 | if (nums.size() == k) { 15 | ans.push_back(nums); 16 | return ; 17 | } 18 | for (int i = x; i <= n; i++) { 19 | if (nums.size() + n - i + 1 < k) 20 | return ; 21 | nums.push_back(i); 22 | dfs(i + 1, k, n, ans, nums); 23 | nums.pop_back(); 24 | } 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /78-subsets.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > subsets(vector &S) { 4 | vector > ans; 5 | int x = 0; 6 | vector v; 7 | sort(S.begin(), S.end()); 8 | for (int i = 0; i <= S.size(); i++) 9 | dfs(x, i, S, v, ans); 10 | return ans; 11 | } 12 | 13 | private: 14 | void dfs(int id, int x, vector &S, vector &v, vector > &ans) { 15 | if (x == 0) { 16 | ans.push_back(v); 17 | return ; 18 | } 19 | for (int i = id; i < S.size(); i++) { 20 | v.push_back(S[i]); 21 | dfs(i + 1, x - 1, S, v, ans); 22 | v.pop_back(); 23 | } 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /79-word-search.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool exist(vector > &board, string word) { 4 | n = board.size(); 5 | if (n == 0) 6 | return false; 7 | m = board[0].size(); 8 | vector > used(n, vector(m, false)); 9 | for (int i = 0; i < n; i++) 10 | for (int k = 0; k < m; k++) { 11 | if (word[0] == board[i][k]) { 12 | if (dfs(i, k, 1, word, board, used)) 13 | return true; 14 | } 15 | } 16 | return false; 17 | } 18 | 19 | private: 20 | int dir[8] = {0, 1, 0, -1, 1, 0, -1, 0}; 21 | int n, m; 22 | 23 | bool dfs(int x, int y, int pos, string &word, vector > &board, vector > &used) { 24 | if (pos == word.size()) 25 | return true; 26 | used[x][y] = true; 27 | for (int i = 0; i < 8; i+=2) { 28 | int xx = x + dir[i]; 29 | int yy = y + dir[i + 1]; 30 | if (xx < n && xx >= 0 && yy < m && yy >= 0 && !used[xx][yy] && 31 | word[pos] == board[xx][yy] && dfs(xx, yy, pos + 1, word, board, used)) 32 | return true; 33 | } 34 | used[x][y] = false; 35 | return false; 36 | } 37 | }; 38 | -------------------------------------------------------------------------------- /8-string-to-integer-atoi.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int atoi(const char *str) { 4 | int flag = 1; 5 | long long ans = 0; 6 | while (*str == ' ') 7 | str++; 8 | flag = 1; 9 | if (*str == '-' || *str == '+') { 10 | if (*str == '-') 11 | flag = -1; 12 | str++; 13 | } 14 | while (*str >= '0' && *str <= '9') { 15 | ans *= 10; 16 | ans += *str - '0'; 17 | str++; 18 | if (ans * flag >= INT_MAX) { 19 | return INT_MAX; 20 | } 21 | if (ans * flag <= INT_MIN) { 22 | return INT_MIN; 23 | } 24 | } 25 | return ans * flag; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /80-remove-duplicates-from-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeDuplicates(int A[], int n) { 4 | int k = 0, i = 0; 5 | for (i = 0; i < n; i++) { 6 | if (i < n - 2 && A[i] == A[i + 1] && A[i] == A[i + 2]) { 7 | A[k++] = A[i]; 8 | A[k++] = A[i]; 9 | while (i < n - 1 && A[i] == A[i + 1]) { 10 | i++; 11 | } 12 | } else { 13 | A[k++] = A[i]; 14 | } 15 | } 16 | return k; 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /81-search-in-rotated-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool search(vector& A, int target) { 4 | int l = 0, r = A.size() - 1; 5 | while (l <= r) { 6 | int mid = l + ((r - l) >> 2); 7 | if (A[mid] == target) 8 | return true; 9 | if (A[l] == A[mid]) { 10 | l++; 11 | continue; 12 | } 13 | if (A[l] < A[mid]) { 14 | if (A[l] <= target && target < A[mid]) 15 | r = mid - 1; 16 | else 17 | l = mid + 1; 18 | } else { 19 | if (A[mid] < target && target <= A[r]) 20 | l = mid + 1; 21 | else 22 | r = mid - 1; 23 | } 24 | } 25 | return false; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /82-remove-duplicates-from-sorted-list-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode * deleteDuplicates(ListNode *head) { 12 | ListNode ans(0); 13 | ans.next = head; 14 | ListNode *pre = &ans; 15 | while (pre->next) { 16 | head = pre->next; 17 | int now = head->val; 18 | if (head->next && head->next->val == now) { 19 | while (head->next && head->next->val == now) 20 | head = head->next; 21 | pre->next = head->next; 22 | } else { 23 | pre = pre->next; 24 | } 25 | } 26 | return ans.next; 27 | } 28 | }; -------------------------------------------------------------------------------- /83-remove-duplicates-from-sorted-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *deleteDuplicates(ListNode *head) { 12 | ListNode *p = head; 13 | while (p && p->next != NULL) { 14 | ListNode *t = p; 15 | while (p->next != NULL && p->next->val == t->val) 16 | p = p->next; 17 | t->next = p->next; 18 | p = t->next; 19 | } 20 | return head; 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /84-largest-rectangle-in-histogram.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int largestRectangleArea(vector &height) { 4 | int ans = 0; 5 | int n = height.size(); 6 | vector lmin(n, -1); 7 | for (int i = 0; i < n; i++) { 8 | int id = i - 1; 9 | while (id != -1 && height[i] <= height[id]) 10 | id = lmin[id]; 11 | lmin[i] = id; 12 | } 13 | 14 | vector rmin(n, n); 15 | for (int i = n - 1; i >= 0; i--) { 16 | int id = i + 1; 17 | while (id != n && height[i] <= height[id]) 18 | id = rmin[id]; 19 | rmin[i] = id; 20 | ans = max(ans, height[i] * (rmin[i] - lmin[i] - 1)); 21 | } 22 | return ans; 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /85-maximal-rectangle.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maximalRectangle(vector > &matrix) { 4 | int row = matrix.size(); 5 | if (row == 0) 6 | return 0; 7 | int col = matrix[0].size(); 8 | vector h(col, 0), l(col, 0), r(col, col); 9 | int ans = 0; 10 | for (int i = 0; i < row; i++) { 11 | int left = 0; 12 | for (int k = 0; k < col; k++) { 13 | if (matrix[i][k] == '1') { 14 | h[k]++; 15 | l[k] = max(left, l[k]); 16 | } else { 17 | left = k + 1; 18 | h[k] = l[k] = 0; 19 | } 20 | } 21 | int right = col; 22 | for (int k = col - 1; k >= 0; k--) { 23 | if (matrix[i][k] == '1') { 24 | r[k] = min(r[k], right); 25 | ans = max(ans, h[k] * (r[k] - l[k])); 26 | } else { 27 | r[k] = col; 28 | right = k; 29 | } 30 | } 31 | } 32 | return ans; 33 | } 34 | 35 | }; 36 | -------------------------------------------------------------------------------- /86-partition-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *partition(ListNode *head, int x) { 12 | ListNode left(0), right(0); 13 | ListNode *lp = &left, *rp = &right; 14 | for (; head; head = head->next) { 15 | if (head->val < x) { 16 | lp->next = head; 17 | lp = lp->next; 18 | } else { 19 | rp->next = head; 20 | rp = rp->next; 21 | } 22 | } 23 | rp->next = NULL; 24 | lp->next = right.next; 25 | return left.next; 26 | } 27 | }; -------------------------------------------------------------------------------- /87-scramble-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isScramble(string s1, string s2) { 4 | if (s1 == s2) 5 | return true; 6 | if (s1.size() != s2.size()) 7 | return false; 8 | int n = s1.size(); 9 | bool dp[n + 1][n][n]; 10 | memset(dp, false, sizeof(dp)); 11 | for (int i = 0; i < n; i++) { 12 | for (int k = 0; k < n; k++) { 13 | dp[1][i][k] = (s1[i] == s2[k]); 14 | } 15 | } 16 | 17 | for (int i = 2; i <= n; i++) { 18 | for (int k = 0; k <= n - i; k++) { 19 | for (int j = 0; j <= n - i; j++) { 20 | for (int cut = 1; cut < i && !dp[i][k][j]; cut++) { 21 | dp[i][k][j] = (dp[cut][k][j] && dp[i - cut][k + cut][j + cut] || 22 | dp[cut][k][j + i - cut] && dp[i - cut][k + cut][j]); 23 | } 24 | } 25 | } 26 | } 27 | return dp[n][0][0]; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /88-merge-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void merge(int A[], int m, int B[], int n) { 4 | int tail = m + n - 1; 5 | int ia = m - 1, ib = n - 1; 6 | while (ia >= 0 && ib >= 0) { 7 | if (A[ia] > B[ib]) { 8 | A[tail--] = A[ia--]; 9 | } else { 10 | A[tail--] = B[ib--]; 11 | } 12 | } 13 | while (ib >= 0) { 14 | A[tail--] = B[ib--]; 15 | } 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /89-gray-code.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector grayCode(int n) { 4 | vector mi; 5 | vector ans; 6 | ans.push_back(0); 7 | for (int i = 0; i < n; i++) 8 | mi.push_back(1 << i); 9 | for (int i = 0; i < n; i++) { 10 | for (int k = ans.size() - 1; k >= 0; k--) 11 | ans.push_back(ans[k] | mi[i]); 12 | } 13 | return ans; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /9-palindrome-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPalindrome(int x) { 4 | int w = 0, v = x; 5 | if (x < 0) 6 | return false; 7 | while (x) { 8 | w *= 10; 9 | w += x % 10; 10 | x /= 10; 11 | } 12 | return v == w; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /90-subsets-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > subsetsWithDup(vector &s) { 4 | vector > ans(1); 5 | 6 | sort(s.begin(), s.end()); 7 | 8 | int pre = s[0], dup = 1; 9 | for (int i = 0; i < s.size(); i++) { 10 | int n = ans.size(); 11 | if (pre != s[i]) 12 | dup = n; 13 | pre = s[i]; 14 | for (int k = n - 1; k >= n - dup; k--) { 15 | ans.push_back(ans[k]); 16 | ans.back().push_back(s[i]); 17 | } 18 | } 19 | return ans; 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /91-decode-ways.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numDecodings(string s) { 4 | int n = s.size(); 5 | if (n == 0) 6 | return 0; 7 | vector dp(n, 0); 8 | dp[0] = 1; 9 | if (s[0] < '1' || s[0] > '9') 10 | return 0; 11 | for (int i = 1; i < n; i++) { 12 | if (s[i] != '0') 13 | dp[i] = dp[i - 1]; 14 | if (s[i] == '0' && s[i - 1] > '2') 15 | return 0; 16 | if (s[i - 1] != '0' && (s[i - 1] - '0') * 10 + s[i] - '0' <= 26) 17 | dp[i] += (i >= 2 ? dp[i - 2] : 1); 18 | } 19 | return dp[n - 1]; 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /92-reverse-linked-list-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *reverseBetween(ListNode *head, int m, int n) { 12 | ListNode ans(0); 13 | ans.next = head; 14 | ListNode *p = &ans, *start = NULL, *last = NULL; 15 | for (int i = 0; i < m - 1; i++) 16 | p = p->next; 17 | last = start = p->next; 18 | for (int i = m; i <= n; i++) { 19 | ListNode *t = last; 20 | last = last->next; 21 | t->next = p->next; 22 | p->next = t; 23 | } 24 | start->next = last; 25 | return ans.next; 26 | } 27 | }; -------------------------------------------------------------------------------- /93-restore-ip-addresses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector restoreIpAddresses(string s) { 4 | vector rst; 5 | dfs(s, 0, rst, "", 0); 6 | return rst; 7 | } 8 | 9 | private : 10 | void dfs(string &s, int x, vector& rst, string now, int d) { 11 | if (x == s.size() && d == 4) { 12 | rst.push_back(now); 13 | return ; 14 | } 15 | if (d == 3) { 16 | string t = s.substr(x, s.size() - x); 17 | if (check(t)) { 18 | now += t; 19 | rst.push_back(now); 20 | } 21 | return ; 22 | } 23 | string w; 24 | for (int i = x; i < x + 3 && i < s.size(); i++) { 25 | w += s[i]; 26 | if (!check(w)) 27 | return ; 28 | if (s.size() - i - 1 <= (4 - d) * 3 && s.size() - i - 1 >= 3 - d) 29 | dfs(s, i + 1, rst, now + w + '.', d + 1); 30 | } 31 | } 32 | bool check(string s) { 33 | int num; 34 | if (s.size() > 3 || s.size() > 1 && s[0] == '0') 35 | return false; 36 | sscanf(s.c_str(), "%d", &num); 37 | return num < 256; 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /94-binary-tree-inorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector inorderTraversal(TreeNode* root) { 13 | vector ans; 14 | pushLeft(root); 15 | while (!stk.empty()) { 16 | TreeNode *p = stk.top(); 17 | ans.push_back(p->val); 18 | stk.pop(); 19 | pushLeft(p->right); 20 | } 21 | return ans; 22 | } 23 | private : 24 | stack stk; 25 | void pushLeft(TreeNode* root) { 26 | while (root) { 27 | stk.push(root); 28 | root = root->left; 29 | } 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /95-unique-binary-search-trees-ii.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector generateTrees(int n) { 13 | vector ans; 14 | dfs(1, n, ans); 15 | return ans; 16 | } 17 | void dfs(int l, int r, vector& tree) { 18 | if (l > r) { 19 | tree.push_back(NULL); 20 | return ; 21 | } 22 | for (int i = l; i <= r; i++) { 23 | vector left, right; 24 | dfs(l, i - 1, left); 25 | dfs(i + 1, r, right); 26 | for (int j = 0; j < left.size(); j++) { 27 | for (int k = 0; k < right.size(); k++) { 28 | TreeNode *root = new TreeNode(i); 29 | root->left = left[j]; 30 | root->right = right[k]; 31 | tree.push_back(root); 32 | } 33 | } 34 | } 35 | 36 | } 37 | }; 38 | -------------------------------------------------------------------------------- /96-unique-binary-search-trees.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numTrees(int n) { 4 | vector dp(n + 1, 0); 5 | dp[0] = 1; 6 | dp[1] = 1; 7 | dp[2] = 2; 8 | dp[3] = 5; 9 | for (int i = 4; i <= n; i++) { 10 | for (int k = 0; k < i; k++) 11 | dp[i] += dp[k] * dp[i - k - 1]; 12 | } 13 | return dp[n]; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /97-interleaving-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isInterleave(string s1, string s2, string s3) { 4 | if (s1.size() + s2.size() != s3.size()) 5 | return false; 6 | if (s3.size() == 0) 7 | return true; 8 | vector > dp(2); 9 | int op = 1; 10 | if (s1[0] == s3[0]) 11 | dp[0][0] = -1; 12 | if (s2[0] == s3[0]) 13 | dp[0][-1] = 0; 14 | for (int i = 1; i < s3.size(); i++) { 15 | if (dp[op ^ 1].size() == 0) 16 | return false; 17 | for (auto& it : dp[op ^ 1]) { 18 | int one = it.first + 1; 19 | int sec = it.second + 1; 20 | if (one < s1.size() && s1[one] == s3[i]) 21 | dp[op][one] = sec - 1; 22 | if (sec < s2.size() && s2[sec] == s3[i]) 23 | dp[op][one - 1] = sec; 24 | } 25 | op ^= 1; 26 | dp[op].clear(); 27 | } 28 | return dp[op ^ 1].size() > 0; 29 | } 30 | }; -------------------------------------------------------------------------------- /98-validate-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isValidBST(TreeNode *root) { 13 | return isValid(root, INT_MIN - 1ll, INT_MAX + 1ll); 14 | } 15 | 16 | private : 17 | bool isValid(TreeNode *root, long long min_val, long long max_val) { 18 | if (root == NULL) 19 | return true; 20 | if (root->val <= min_val || root->val >= max_val) 21 | return false; 22 | return isValid(root->left, min_val, root->val) && isValid(root->right, root->val, max_val); 23 | } 24 | }; -------------------------------------------------------------------------------- /99-recover-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void recoverTree(TreeNode *root) { 13 | travel(root); 14 | swap(wrong[0]->val, wrong[1]->val); 15 | } 16 | 17 | private: 18 | vector wrong; 19 | TreeNode *pre = NULL; 20 | void travel(TreeNode *root) { 21 | if (root == NULL) 22 | return ; 23 | travel(root->left); 24 | if (pre != NULL && root->val < pre->val) { 25 | if (wrong.size() == 0) { 26 | wrong.push_back(pre); 27 | wrong.push_back(root); 28 | } else { 29 | wrong[1] = root; 30 | } 31 | } 32 | pre = root; 33 | travel(root->right); 34 | } 35 | }; 36 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | The solutions of leetcode OJ. 2 | go go ~! 3 | --------------------------------------------------------------------------------