# | Title | Acceptance | Difficulty | Frequency | Tags | Done/Lock |
---|---|---|---|---|---|---|

1 | Two Sum | 31.8% | Easy | High | Array, Hash Table | Done |

2 | Add Two Numbers | 27.0% | Medium | Linked List, Math | ||

3 | Longest Substring Without Repeating Characters | 24.0% | Medium | High | Hash Table, Two Pointers, String | Done |

4 | Median of Two Sorted Arrays | 21.2% | Hard | Binary Search, Array, Divide and Conquer | ||

5 | Longest Palindromic Substring | 25.0% | Medium | String | ||

6 | ZigZag Conversion | 26.3% | Medium | String | ||

7 | Reverse Integer | 23.9% | Easy | Math | ||

8 | String to Integer (atoi) | 13.9% | Medium | Math, String | ||

9 | Palindrome Number | 34.4% | Easy | Math | ||

10 | Regular Expression Matching | 23.9% | Hard | Dynamic Programming, Backtracking, String | ||

11 | Container With Most Water | 36.2% | Medium | Array, Two Pointers | ||

12 | Integer to Roman | 43.5% | Medium | Math, String | ||

13 | Roman to Integer | 44.4% | Easy | Math, String | ||

14 | Longest Common Prefix | 31.0% | Easy | String | ||

15 | 3Sum | 21.3% | Medium | Array, Two Pointers | ||

16 | 3Sum Closest | 30.7% | Medium | Array, Two Pointers | ||

17 | Letter Combinations of a Phone Number | 33.3% | Medium | Backtracking, String | ||

18 | 4Sum | 26.0% | Medium | Array, Hash Table, Two Pointers | Skip | |

19 | Remove Nth Node From End of List | 32.6% | Medium | Linked List, Two Pointers | ||

20 | Valid Parentheses | 32.7% | Easy | Stack, String | ||

21 | Merge Two Sorted Lists | 38.4% | Easy | Linked List | ||

22 | Generate Parentheses | 42.9% | Medium | Backtracking, String | ||

23 | Merge k Sorted Lists | 26.5% | Hard | Divide and Conquer, Linked List, Heap | ||

24 | Swap Nodes in Pairs | 37.5% | Medium | Linked List | ||

25 | Reverse Nodes in k-Group | 30.1% | Hard | Linked List | ||

26 | Remove Duplicates from Sorted Array | 35.4% | Easy | Array, Two Pointers | ||

27 | Remove Element | 37.7% | Easy | Array, Two Pointers | ||

28 | Implement strStr() | 27.4% | Easy | Two Pointers, String | ||

29 | Divide Two Integers | 16.0% | Medium | Math, Binary Search | ||

30 | Substring with Concatenation of All Words | 21.8% | Hard | Hash Table, Two Pointers, String | ||

31 | Next Permutation | 28.4% | Medium | Array | ||

32 | Longest Valid Parentheses | 23.0% | Hard | Dynamic Programming, String | ||

33 | Search in Rotated Sorted Array | 32.1% | Medium | Binary Search, Array | ||

34 | Search for a Range | 31.1% | Medium | Binary Search, Array | ||

35 | Search Insert Position | 39.2% | Easy | Array, Binary Search | ||

36 | Valid Sudoku | 34.6% | Medium | Hash Table | Done | |

37 | Sudoku Solver | 28.9% | Hard | Backtracking, Hash Table | ||

38 | Count and Say | 33.3% | Easy | String | ||

39 | Combination Sum | 36.8% | Medium | Array, Backtracking | ||

40 | Combination Sum II | 32.1% | Medium | Array, Backtracking | ||

41 | First Missing Positive | 25.1% | Hard | Array | ||

42 | Trapping Rain Water | 35.9% | Hard | Array, Stack, Two Pointers | ||

43 | Multiply Strings | 26.4% | Medium | Math, String | ||

44 | Wildcard Matching | 19.5% | Hard | Dynamic Programming, Backtracking, Greedy, String | ||

45 | Jump Game II | 26.1% | Hard | Array, Greedy | ||

46 | Permutations | 41.6% | Medium | Backtracking | ||

47 | Permutations II | 31.6% | Medium | Backtracking | ||

48 | Rotate Image | 37.7% | Medium | Array | ||

49 | Group Anagrams | 32.9% | Medium | Hash Table, String | Done | |

50 | Pow(x, n) | 26.8% | Medium | Binary Search, Math | ||

51 | N-Queens | 29.7% | Hard | Backtracking | ||

52 | N-Queens II | 43.4% | Hard | Backtracking | ||

53 | Maximum Subarray | 39.1% | Easy | Array, Dynamic Programming, Divide and Conquer | ||

54 | Spiral Matrix | 25.1% | Medium | Array | ||

55 | Jump Game | 29.3% | Medium | Array, Greedy | ||

56 | Merge Intervals | 29.1% | Medium | Array, Sort | ||

57 | Insert Interval | 26.8% | Hard | Array, Sort | ||

58 | Length of Last Word | 31.4% | Easy | String | ||

59 | Spiral Matrix II | 38.5% | Medium | Array | ||

60 | Permutation Sequence | 27.6% | Medium | Backtracking, Math | ||

61 | Rotate List | 24.2% | Medium | Linked List, Two Pointers | ||

62 | Unique Paths | 39.9% | Medium | Array, Dynamic Programming | ||

63 | Unique Paths II | 31.2% | Medium | Array, Dynamic Programming | ||

64 | Minimum Path Sum | 37.6% | Medium | Array, Dynamic Programming | ||

65 | Valid Number | 12.7% | Hard | Math, String | ||

66 | Plus One | 37.6% | Easy | Array, Math | ||

67 | Add Binary | 31.2% | Easy | Math, String | ||

68 | Text Justification | 18.5% | Hard | String | ||

69 | Sqrt(x) | 27.3% | Easy | Binary Search, Math | ||

70 | Climbing Stairs | 39.1% | Easy | Dynamic Programming | ||

71 | Simplify Path | 24.5% | Medium | Stack, String | ||

72 | Edit Distance | 31.0% | Hard | Dynamic Programming, String | ||

73 | Set Matrix Zeroes | 35.4% | Medium | Array | ||

74 | Search a 2D Matrix | 35.3% | Medium | Array, Binary Search | ||

75 | Sort Colors | 37.1% | Medium | Array, Two Pointers, Sort | ||

76 | Minimum Window Substring | 24.4% | Hard | Hash Table, Two Pointers, String | ||

77 | Combinations | 38.5% | Medium | Backtracking | ||

78 | Subsets | 38.1% | Medium | Array, Backtracking, Bit Manipulation | ||

79 | Word Search | 25.8% | Medium | Array, Backtracking | ||

80 | Remove Duplicates from Sorted Array II | 35.2% | Medium | Array, Two Pointers | ||

81 | Search in Rotated Sorted Array II | 32.8% | Medium | Array, Binary Search | ||

82 | Remove Duplicates from Sorted List II | 28.9% | Medium | Linked List | ||

83 | Remove Duplicates from Sorted List | 39.2% | Easy | Linked List | ||

84 | Largest Rectangle in Histogram | 26.0% | Hard | Array, Stack | ||

85 | Maximal Rectangle | 26.8% | Hard | Array, Hash Table, Stack, Dynamic Programming | ||

86 | Partition List | 31.9% | Medium | Linked List, Two Pointers | ||

87 | Scramble String | 28.5% | Hard | Dynamic Programming, String | ||

88 | Merge Sorted Array | 31.6% | Easy | Array, Two Pointers | ||

89 | Gray Code | 40.0% | Medium | Backtracking | ||

90 | Subsets II | 34.8% | Medium | Array, Backtracking | ||

91 | Decode Ways | 19.2% | Medium | Dynamic Programming, String | ||

92 | Reverse Linked List II | 30.1% | Medium | Linked List | ||

93 | Restore IP Addresses | 26.3% | Medium | Backtracking, String | ||

94 | Binary Tree Inorder Traversal | 44.9% | Medium | Tree, Hash Table, Stack | ||

95 | Unique Binary Search Trees II | 30.8% | Medium | Tree, Dynamic Programming | ||

96 | Unique Binary Search Trees | 40.2% | Medium | Tree, Dynamic Programming | ||

97 | Interleaving String | 24.2% | Hard | Dynamic Programming, String | ||

98 | Validate Binary Search Tree | 22.7% | Medium | Tree, Depth-First Search | ||

99 | Recover Binary Search Tree | 29.1% | Hard | Tree, Depth-First Search | ||

100 | Same Tree | 45.7% | Easy | Tree, Depth-First Search | ||

101 | Symmetric Tree | 37.6% | Easy | Tree, Depth-First Search, Breadth-First Search | ||

102 | Binary Tree Level Order Traversal | 38.0% | Medium | Tree, Breadth-First Search | ||

103 | Binary Tree Zigzag Level Order Traversal | 33.1% | Medium | Tree, Breadth-First Search, Stack | ||

104 | Maximum Depth of Binary Tree | 51.5% | Easy | Tree, Depth-First Search | ||

105 | Construct Binary Tree from Preorder and Inorder Traversal | 31.2% | Medium | Tree, Array, Depth-First Search | ||

106 | Construct Binary Tree from Inorder and Postorder Traversal | 31.3% | Medium | Tree, Array, Depth-First Search | ||

107 | Binary Tree Level Order Traversal II | 38.7% | Easy | Tree, Breadth-First Search | ||

108 | Convert Sorted Array to Binary Search Tree | 41.1% | Easy | Tree, Depth-First Search | ||

109 | Convert Sorted List to Binary Search Tree | 33.2% | Medium | Depth-First Search, Linked List | ||

110 | 110. Balanced Binary Tree | 36.6% | Easy | Tree, Depth-First Search | ||

111 | Minimum Depth of Binary Tree | 32.6% | Easy | Tree, Depth-First Search, Breadth-First Search | ||

112 | Path Sum | 33.3% | Easy | Tree, Depth-First Search | ||

113 | Path Sum II | 32.3% | Medium | Tree, Depth-First Search | ||

114 | Flatten Binary Tree to Linked List | 34.1% | Medium | Tree, Depth-First Search | ||

115 | Distinct Subsequences | 30.9% | Hard | Dynamic Programming, String | ||

116 | Populating Next Right Pointers in Each Node | 36.9% | Medium | Tree, Depth-First Search | ||

117 | Populating Next Right Pointers in Each Node II | 33.6% | Medium | Tree, Depth-First Search | ||

118 | Pascal’s Triangle | 37.4% | Easy | Array | ||

119 | Pascal’s Triangle II | 35.7% | Easy | Array | ||

120 | Triangle | 32.9% | Medium | Array, Dynamic Programming | ||

121 | Best Time to Buy and Sell Stock | 40.0% | Easy | Array, Dynamic Programming | ||

122 | Best Time to Buy and Sell Stock II | 46.1% | Easy | Array, Greedy | ||

123 | Best Time to Buy and Sell Stock III | 28.6% | Hard | Array, Dynamic Programming | ||

124 | Binary Tree Maximum Path Sum | 25.4% | Hard | Tree, Depth-First Search | ||

125 | Valid Palindrome | 25.7% | Easy | Two Pointers, String | ||

126 | Word Ladder II | 13.7% | Hard | Array, Backtracking, Breadth-First Searching, String | ||

127 | Word Ladder | 19.2% | Medium | |||

128 | Longest Consecutive Sequence | 35.9% | Hard | Array, Union Find | ||

129 | Sum Root to Leaf Numbers | 35.6% | Medium | Tree, Depth-First Search | ||

130 | Surrounded Regions | 17.8% | Medium | Breadth-First Search, Union Find | ||

131 | Palindrome Partitioning | 31.7% | Medium | Backtracking | ||

132 | Palindrome Partitioning II | 23.7% | Hard | Dynamic Programming | ||

133 | Clone Graph | 25.1% | Medium | Depth-First Search, Breadth-First Search, Graph | ||

134 | Gas Station | 28.8% | Medium | Greedy | ||

135 | Candy | 24.2% | Hard | Greedy | ||

136 | Single Number | 53.4% | Easy | Hash Table, Bit Manipulation | ||

137 | Single Number II | 40.6% | Medium | Bit Manipulation | ||

138 | Copy List with Random Pointer | 26.5% | Medium | Hash, Table, Linked List | ||

139 | Word Break | 28.9% | Medium | Dynamic Programming | ||

140 | Word Break II | 22.6% | Hard | Dynamic Programming, Backtracking | ||

141 | Linked List Cycle | 35.6% | Easy | Linked List, Two Pointers | ||

142 | Linked List Cycle II | 31.0% | Medium | Linked List, Two Pointers | ||

143 | Reorder List | 24.9% | Medium | Linked List | ||

144 | Binary Tree Preorder Traversal | 43.8% | Medium | Tree, Stack | ||

145 | Binary Tree Postorder Traversal | 39.1% | Hard | Tree, Stack | ||

146 | LRU Cache | 16.7% | Hard | Design | ||

147 | Insertion Sort List | 32.2% | Medium | Linked List, Sort | ||

148 | Sort List | 27.8% | Medium | Linked List, Sort | ||

149 | Max Points on a Line | 15.5% | Hard | Hash Table, Math | ||

150 | Evaluate Reverse Polish Notation | 26.4% | Medium | Stack | ||

151 | Reverse Words in a String | 15.7% | Medium | String | ||

152 | Maximum Product Subarray | 24.9% | Medium | Array, Dynamic Programming | ||

153 | Find Minimum in Rotated Sorted Array | 39.1% | Medium | Array, Binary Search | ||

154 | Find Minimum in Rotated Sorted Array II | 36.5% | Hard | Array, Binary Search | ||

155 | Min Stack | 27.2% | Easy | Stack, Design | ||

156 | Binary Tree Upside Down | 43.4% | Medium | Y | ||

157 | Read N Characters Given Read4 | 29.2% | Easy | Y | ||

158 | Read N Characters Given Read4 II – Call multiple times | 24.3% | Hard | Y | ||

159 | Longest Substring with At Most Two Distinct Characters | 40.1% | Hard | Y | ||

160 | Intersection of Two Linked Lists | 30.2% | Easy | Linked List | ||

161 | One Edit Distance | 30.8% | Medium | Y | ||

162 | Find Peak Element | 36.4% | Medium | Binary Search, Array | ||

163 | Missing Ranges | 25.7% | Medium | Y | ||

164 | Maximum Gap | 28.9% | Hard | Sort | ||

165 | Compare Version Numbers | 19.6% | Medium | String | ||

166 | Fraction to Recurring Decimal | 17.1% | Medium | Hash Table, Math | ||

167 | Two Sum II – Input array is sorted | 47.5% | Easy | Array, Two Pointers, Binary Search | ||

168 | Excel Sheet Column Title | 25.1% | Easy | Math | ||

169 | Majority Element | 45.5% | Easy | Array, Divide and Conquer, Bit Manipulation | ||

170 | Two Sum III – Data structure design | 23.4% | Easy | Y | ||

171 | Excel Sheet Column Number | 46.0% | Easy | Math | ||

172 | Factorial Trailing Zeroes | 35.4% | Easy | Math | ||

173 | Binary Search Tree Iterator | 40.0% | Medium | Tree, Stack, Design | ||

174 | Dungeon Game | 23.2% | Hard | Binary Search, Dynamic Programming | ||

179 | Largest Number | 21.9% | Medium | Sort | ||

186 | Reverse Words in a String II | 27.9% | Medium | Y | ||

187 | Repeated DNA Sequences | 30.3% | Medium | Hash Table, Bit Manipulation | ||

188 | Best Time to Buy and Sell Stock IV | 24.0% | Hard | Dynamic Programming | ||

189 | Rotate Array | 23.9% | Easy | Array | ||

190 | Reverse Bits | 29.5% | Easy | Bit Manipulation | ||

191 | Number of 1 Bits | 38.9% | Easy | Bit Manipulation | ||

198 | House Robber | 38.0% | Easy | Dynamic Programming | ||

199 | Binary Tree Right Side View | 39.6% | Medium | Tree, Depth-First Search, Breadth-First Search | ||

200 | Number of Islands | 33.3% | Medium | Depth-First Search, Breadth-First Search, Union Find | ||

201 | Bitwise AND of Numbers Range | 33.4% | Medium | Bit Manipulation | ||

202 | Happy Number | 39.8% | Easy | Hash Table, Math | ||

203 | Remove Linked List Elements | 31.5% | Easy | Linked List | ||

204 | Count Primes | 26.3% | Easy | Hash Table, Math | ||

205 | Isomorphic Strings | 33.0% | Easy | Hash Table | ||

206 | Reverse Linked List | 44.4% | Easy | Linked List | ||

207 | Course Schedule | 31.1% | Medium | Depth-First Search, Breadth-First Search, Graph, Topological Sort | ||

208 | Implement Trie (Prefix Tree) | 26.7% | Medium | Design, Tree | ||

209 | Minimum Size Subarray Sum | 29.5% | Medium | Array, Two Pointers, Binary Search | ||

210 | Course Schedule II | 26.5% | Medium | Depth-First Search, Breadth-First Search, Graph, Topological Sort | ||

211 | Add and Search Word – Data structure design | 21.2% | Medium | Backtracking, Trie, Design | ||

212 | Word Search II | 22.8% | Hard | Backtracking, Trie | ||

213 | House Robber II | 33.4% | Medium | Dynamic Programming | ||

214 | Shortest Palindrome | 23.5% | Hard | String | ||

215 | Kth Largest Element in an Array | 38.2% | Medium | Heap, Divide and Conquer | ||

216 | Combination Sum III | 43.2% | Medium | Array, Backtracking | ||

217 | Contains Duplicate | 44.6% | Easy | Array, Hash Table | ||

218 | The Skyline Problem | 26.4% | Hard | Binary Indexed Tree, Segment Tree, Heap, Divide and Conquer | ||

219 | Contains Duplicate II | 31.9% | Easy | Array, Hash Table | ||

220 | Contains Duplicate III | 19.3% | Medium | Binary Search Tree | ||

221 | Maximal Square | 27.8% | Medium | Dynamic Programming | ||

222 | Count Complete Tree Nodes | 27.1% | Medium | Tree, Binary Search | ||

223 | Rectangle Area | 32.3% | Medium | Math | ||

224 | Basic Calculator | 26.2% | Hard | Stack, Math | ||

225 | Implement Stack using Queues | 31.8% | Easy | Stack, Design | ||

226 | Invert Binary Tree | 50.6% | Easy | Tree | ||

227 | Basic Calculator II | 28.6% | Medium | String | ||

228 | Summary Ranges | 28.7% | Medium | Array | ||

229 | Majority Element II | 28.1% | Medium | Array | ||

230 | Kth Smallest Element in a BST | 42.7% | Medium | Binary Search, Tree | ||

231 | Power of Two | 39.6% | Easy | Math, Bit Manipulation | ||

232 | Implement Queue using Stacks | 35.7% | Easy | Stack, Design | ||

233 | Number of Digit One | 27.7% | Hard | Math | ||

234 | Palindrome Linked List | 32.0% | Easy | Linked List, Two Pointers | ||

235 | Lowest Common Ancestor of a Binary Search Tree | 38.4% | Easy | Tree | ||

236 | Lowest Common Ancestor of a Binary Tree | 29.6% | Medium | Tree | ||

237 | Delete node in a linked list | 45.8% | Easy | Linked List | ||

238 | Product of Array Except Self | 48.0% | Medium | Array | ||

239 | Sliding Window Maximum | 32.0% | Hard | Heap | ||

240 | Search a 2D Matrix II | 38.0% | Medium | Binary Search, Divide and Conquer | ||

241 | Different Ways to Add Parentheses | 42.3% | Medium | Divide and Conquer | ||

242 | Valid Anagram | 45.5% | Easy | Hash Table, Sort | ||

243 | Shortest Word Distance | 51.4% | Easy | Y | ||

244 | Shortest Word Distance II | 35.8% | Medium | Y | ||

245 | Shortest Word Distance III | 49.7% | Medium | Y | ||

246 | Strobogrammatic Number | 39.3% | Easy | Y | ||

247 | Strobogrammatic Number II | 38.9% | Medium | Y | ||

248 | Strobogrammatic Number III | 31.0% | Hard | Y | ||

249 | Group Shifted Strings | 40.0% | Medium | Y | ||

250 | Count Univalue Subtrees | 41.1% | Medium | Y | ||

251 | Flatten 2D Vector | 39.6% | Medium | Y | ||

252 | Meeting rooms | 46.4% | Easy | Y | ||

253 | Meeting Rooms II | 38.6% | Medium | Y | ||

254 | Factor Combinations | 41.5% | Medium | Y | ||

255 | Verify Preorder Sequence in Binary Search Tree | 39.4% | Medium | Y | ||

256 | Paint House | 45.9% | Easy | Y | ||

257 | Binary Tree Paths | 36.5% | Easy | Tree, Depth-First Search | ||

258 | Add Digits | 50.6% | Easy | Math | ||

259 | 3Sum Smaller | 41.0% | Medium | Y | ||

260 | Single Number III | 50.2% | Medium | Bit Manipulation | ||

261 | Graph Valid Tree | 37.2% | Medium | Y | ||

263 | Ugly Number | 38.7% | Easy | Math | ||

264 | Ugly Number II | 32.0% | Medium | Dynamic Programming, Heap, Math | ||

265 | Paint House II | 37.7% | Hard | Y | ||

266 | Palindrome Permutation | 56.1% | Easy | Y | ||

267 | Palindrome Permutation II | 31.5% | Medium | Y | ||

268 | Missing Number | 43.9% | Easy | Array, Math, Bit Manipulation | ||

269 | Alien Dictionary | 22.5% | Hard | Y | ||

270 | Closest Binary Search Tree Value | 38.7% | Easy | Y | ||

271 | Encode and Decode Strings | 26.2% | Medium | Y | ||

272 | Closest Binary Search Tree Value II | 38.2% | Hard | Y | ||

273 | Integer to English Words | 21.6% | Hard | Math, String | ||

274 | H-Index | 32.6% | Medium | Hash Table, Sort | ||

275 | H-Index II | 33.8% | Medium | Binary Search | ||

276 | Paint Fence | 34.2% | Easy | Y | ||

277 | Find the Celebrity | 35.5% | Medium | Y | ||

278 | First Bad Version | 24.7% | Easy | Binary Search | ||

279 | Perfect Squares | 35.8% | Medium | Dynamic Programming, Breadth-First Search, Math | ||

280 | Wiggle Sort | 56.0% | Medium | Y | ||

281 | Zigzag Iterator | 49.4% | Medium | Y | ||

282 | Expression Add Operators | 29.2% | Hard | Divide and Conquer | ||

283 | Move Zeroes | 48.7% | Easy | Array, Two Pointers | ||

284 | Peeking Iterator | 35.2% | Medium | Design | ||

285 | Inorder Successor in BST | 36.1% | Medium | Y | ||

286 | Walls and Gates | 43.3% | Medium | Y | ||

287 | Find the Duplicate Number | 42.5% | Medium | Binary Search, Array, Two Pointers | ||

288 | Unique Word Abbreviation | 15.9% | Medium | Y | ||

289 | Game of Life | 36.5% | Medium | Array | ||

290 | Word Pattern | 32.5% | Easy | Hash Table | ||

291 | Word Pattern II | 37.8% | Hard | Y | ||

292 | Nim Game | 54.9% | Easy | Brainteaser | ||

293 | Flip Game | 54.7% | Easy | Y | ||

294 | Flip Game II | 45.8% | Medium | Y | ||

295 | Find Median from Data Stream | 24.7% | Hard | Heap, Design | ||

296 | Best Meeting Point | 51.1% | Hard | Y | ||

297 | Serialize and Deserialize Binary Tree | 32.4% | Hard | Tree, Design | ||

298 | Binary Tree Longest Consecutive Sequence | 40.3% | Medium | Y | ||

299 | Bulls and Cows | 33.8% | Medium | Hash Table | ||

300 | Longest Increasing Subsequence | 37.7% | Medium | Dynamic Programming, Binary Search | ||

301 | Remove Invalid Parentheses | 34.9% | Hard | Depth-First Search, Breadth-First Search | ||

302 | Smallest Rectangle Enclosing Black Pixels | 44.6% | Hard | Y | ||

303 | Range Sum Query – Immutable | 27.5% | Easy | Dynamic Programming | ||

304 | Range Sum Query 2D – Immutable | 23.6% | Medium | Dynamic Programming | ||

305 | Number of Islands II | 38.6% | Hard | Y | ||

306 | Additive Number | 27.3% | Medium | N/A | ||

307 | Range Sum Query – Mutable | 19.3% | Medium | Segment Tree, Binary Indexed Tree | ||

308 | Range Sum Query 2D- Mutable | 21.3% | Hard | Y | ||

309 | Best Time to Buy and Sell Stock with Cooldown | 40.1% | Medium | Dynamic Programming | ||

310 | Minimum Height Trees | 28.6% | Medium | Breadth-First Search, Graph | ||

311 | 50.6% | Medium | Y | |||

312 | Burst Balloons | 41.9% | Hard | Dynamic Programming, Divide and Conquer | ||

313 | Super Ugly Number | 37.3% | Medium | Math, Heap | ||

314 | 36.1% | Medium | Y | |||

315 | 34.0% | Hard | Divide and Conquer, Binary Indexed Tree, Segment Tree, Binary Search Tree | |||

316 | Remove Duplicate Letters | 29.0% | Hard | Stack, Greedy | ||

317 | Shortest Distance from All Buildings | 33.5% | Hard | Y | ||

318 | Maximum Product of Word Lengths | 43.1% | Medium | Bit Manipulation | ||

319 | Bulb Switcher | 42.1% | Medium | Math, Brainteaser | ||

320 | Generalized Abbreviation | 44.1% | Medium | Y | ||

321 | Create Maximum Number | 24.2% | Hard | Dynamic Programming, Greedy | ||

322 | Coin Change | 26.2% | Medium | Dynamic Programming | ||

323 | 47.3% | Medium | Y | |||

324 | Wiggle Sort II | 25.5% | Medium | Sort | ||

325 | Maximum Size Subarray Sum Equals k | 42.0% | Medium | Y | ||

326 | Power of Three | 39.7% | Easy | Math | ||

327 | 29.2% | Hard | Divide and Conquer, Binary Search Tree | |||

328 | Odd Even Linked List | 42.5% | Medium | Linked List | ||

329 | 35.8% | Hard | Depth-First Search, Topological Search, Memoization | |||

330 | Patching Array | 31.6% | Hard | Greedy | ||

331 | 35.6% | Medium | Stack | |||

332 | 28.4% | Medium | Depth-First Search, Graph | |||

333 | Largest BST Subtree | 30.1% | Medium | Y | ||

334 | 38.4% | Medium | N/A | |||

335 | Self Crossing | 24.5% | Hard | Math | ||

336 | 25.3% | Hard | Hash Table, String, Trie | |||

337 | 42.3% | Medium | Tree, Depth-First Search | |||

338 | 60.2% | Medium | Dynamic Programming, Bit Manipulation | |||

339 | Nested List Weight Sum | 60.7% | Easy | Y | ||

340 | 38.4% | Hard | Y | |||

341 | 40.0% | Medium | Stack, Design | |||

342 | 37.9% | Easy | Bit Manipulation | |||

343 | 45.3% | Medium | Dynamic Programming, Math | |||

344 | 58.2% | Easy | Two Pointers, String | |||

345 | 37.8% | Easy | Two Pointers, String | |||

346 | 58.1% | Easy | Y | |||

347 | 47.0% | Medium | Hash Table, Heap | |||

348 | 45.5% | Medium | Y | |||

349 | 46.4% | Easy | Binary Search, Hash Table, Two Pointers, Sort | |||

350 | 44.0% | Easy | Binary Search, Hash Table, Two Pointers, Sort | |||

351 | 43.2% | Medium | Y | |||

352 | 39.3% | Hard | Binary Search Tree | |||

353 | 26.0% | Medium | ||||

354 | 31.9% | Hard | Binary Search, Dynamic Programming | |||

355 | 25.1% | Medium | Hash Table, Heap, Design | |||

356 | 30.3% | Medium | Y | |||

357 | 45.4% | Medium | Dynamic Programming, Backtracking, Math | |||

358 | 31.8% | Hard | Y | |||

359 | 58.8% | Easy | Y | |||

360 | 43.4% | Medium | Y | |||

361 | 38.4% | Medium | Y | |||

362 | 53.1% | Medium | Y | |||

363 | 32.5% | Hard | Binary Search,Dynamic Programming, Queue | |||

364 | 51.1% | Medium | Y | |||

365 | 26.5% | Medium | Math | |||

366 | 58.2% | Medium | ||||

367 | 37.8% | Easy | Binary Search, Math | |||

368 | 33.4% | Medium | Dynamic Programming, Math | |||

369 | 53.7% | Medium | Y | |||

370 | 54.4% | Medium | Y | |||

371 | 51.1% | Easy | Bit Manipulation | |||

372 | 33.6% | Medium | Math | |||

373 | 30.3% | Medium | Heap | |||

374 | 34.3% | Easy | Binary Search | |||

375 | 35.6% | Medium | Dynamic Programming, Minimax | |||

376 | 34.9% | Medium | Dynamic Programming, Greedy | |||

377 | 41.7% | Medium | Dynamic Programming | |||

378 | 43.7% | Medium | Binary Search, Heap | |||

379 | 31.1% | Medium | Y | |||

380 | 38.9% | Medium | Array, Hash Table, Design | |||

381 | 28.4% | Hard | Array, Hash Table, Design | |||

382 | 46.5% | Medium | Reservoir Sampling | |||

383 | 46.5% | Easy | String | |||

384 | 45.5% | Medium | N/A | |||

385 | 30.1% | Medium | Stack, String | |||

386 | 40.3% | Medium | N/A | |||

387 | 46.1% | Easy | N/A | |||

388 | 35.6% | Medium | N/A | |||

389 | 51.3% | Easy | Hash Table, Bit Manipulation | |||

390 | 39.9% | Medium | N/A | |||

391 | 25.4% | Hard | N/A | |||

392 | 44.2% | Medium | Binary Search, Dynamic Programming, Greedy | |||

393 | 34.6% | Medium | Bit Manipulation | |||

394 | 40.8% | Medium | Depth-First Search, Stack | |||

395 | 35.5% | Medium | N/A | |||

396 | 31.2% | Medium | Math | |||

397 | 29.6% | Medium | Math, Bit Manipulation | |||

398 | 41.5% | Medium | Reservoir Sampling | |||

399 | 40.1% | Medium | Math | |||

400 | 30.1% | Easy | Math | |||

401 | 44.6% | Easy | Backtracking, Bit Manipulation | |||

402 | 26.1% | Medium | Stack, Greedy | |||

403 | 31.3% | Hard | Dynamic Programming | |||

404 | 46.4% | Easy | Tree | |||

405 | 40.6% | Easy | Bit Manipulation | |||

406 | 54.7% | Medium | Greedy | |||

407 | 36.1% | Hard | Breadth-First Search, Heap | |||

408 | 27.5% | Easy | Y | |||

409 | 44.9% | Easy | Hash Table | |||

410 | 34.6% | Hard | Binary Search, Dynamic Programming | |||

411 | 31.7% | Hard | Y | |||

412 | 58.7% | Easy | N/A | |||

413 | 54.8% | Medium | Dynamic Programming, Math | |||

414 | 27.2% | Easy | Array | |||

415 | 41.2% | Easy | Math | |||

416 | 38.2% | Medium | Dynamic Programming | |||

417 | 33.1% | Medium | Depth-First Search, Breadth-First Search | |||

418 | 27.3% | Medium | Y | |||

419 | 60.6% | Medium | N/A | |||

420 | 20.3% | Hard | N/A | |||

421 | 44.2% | Medium | Bit Manipulation, Trie | |||

422 | 36.1% | Easy | Y | |||

423 | 43.1% | Medium | Math | |||

424 | 41.1% | Medium | N/A | |||

425 | 42.6% | Hard | ||||

432 | 27.6% | Hard | Design | |||

434 | 37.1% | Easy | String | |||

435 | 40.1% | Medium | Greedy | |||

436 | 41.1% | Medium | Binary Search | |||

437 | 39.0% | Easy | Tree | |||

438 | 33.5% | Easy | Hash Table | |||

439 | 49.9% | Medium | Y | |||

440 | 23.0% | Hard | N/A | |||

441 | 36.0% | Easy | Binary Search, Math | |||

442 | 52.9% | Medium | Array | |||

444 | 19.7% | Medium | Y | |||

445 | 46.2% | Medium | Linked List | |||

446 | 24.9% | Hard | Dynamic Programming | |||

447 | 43.5% | Easy | Hash Table | |||

448 | 52.8% | Easy | Array | |||

449 | 42.2% | Medium | Tree | |||

450 | 35.5% | Medium | Tree | |||

451 | 50.3% | Medium | Hash Table, Heap | |||

452 | 42.7% | Medium | Greedy | |||

453 | 46.6% | Easy | Math | |||

454 | 45.4% | Medium | Binary Search, Hash Table | |||

455 | 47.2% | Easy | Greedy | |||

456 | 28.2% | Medium | Stack | |||

459 | 38.4% | Easy | String | |||

460 | 22.1% | Hard | Design | |||

461 | 70.6% | Easy | Bit Manipulation | |||

462 | 51.2% | Medium | Math | |||

463 | 56.6% | Easy | Hash Table | |||

464 | 23.6% | Medium | Dynamic Programming, Minimax | |||

465 | 33.2% | Hard | Y | |||

466 | 25.7% | Hard | Dynamic Programming | |||

467 | 31.5% | Medium | Dynamic Programming | |||

468 | 20.2% | Medium | String | |||

469 | 30.1% | Medium | ||||

471 | 42.0% | Hard | ||||

472 | 29.7% | Hard | Dynamic Programming, Trie, Depth-First Search | |||

473 | 34.1% | Medium | Depth-First Search | |||

474 | 37.3% | Medium | Dynamic Programming | |||

475 | 29.7% | Easy | Binary Search | |||

476 | 61.0% | Easy | Bit Manipulation | |||

477 | 46.0% | Medium | Bit Manipulation | |||

480 | 31.5% | Hard | N/A | |||

481 | 45.3% | Medium | N/A | |||

482 | 41.1% | Medium | N/A | |||

483 | 30.9% | Hard | Binary Search, Math | |||

484 | 52.0% | Medium | Y | |||

485 | 54.7% | Easy | Array | |||

486 | 44.2% | Medium | Dynamic Programming, Minimax | |||

487 | 44.2% | Medium | Y | |||

488 | 37.0% | Hard | Depth-First Search | |||

490 | 42.1% | Medium | Y | |||

491 | 38.6% | Medium | Depth-First Search | |||

492 | 48.9% | Easy | N/A | |||

493 | 18.5% | Hard | Binary Indexed Tree, Segment Tree, Binary Search Tree, Divide and Conquer | |||

494 | 44.0% | Medium | Depth-First Search, Dynamic Programming | |||

495 | 51.5% | Medium | Array | |||

496 | 57.6% | Easy | Stack | |||

498 | 46.4% | Medium | N/A | |||

499 | 31.6% | Hard | Y | |||

500 | 60.3% | Easy | Hash Table | |||

501 | 38.9% | Easy | Tree | |||

502 | 33.6% | Hard | Heap, Greedy | |||

503 | 46.6% | Medium | Stack | |||

504 | 45.7% | Easy | N/A | |||

505 | 35.5% | Medium | Y | |||

506 | 47.4% | Easy | N/A | |||

507 | 29.5% | Easy | Math | |||

508 | 51.7% | Medium | Tree, Hash Table | |||

513 | 55.6% | Medium | Tree, Depth-First Search, Breadth-First Search | |||

514 | 33.0% | Hard | “Dynamic Programming”, Depth-First Search, Divide and Conquer | |||

515 | 53.1% | Medium | Tree, Depth-First Search, Breadth-First Search | |||

516 | 42.0% | Medium | Dynamic Programming | |||

517 | 35.4% | Hard | Dynamic Programming, Math | |||

520 | 52.7% | Easy | String | |||

523 | 21.3% | Medium | Dynamic Programming, Math | |||

524 | 40.3% | Medium | Two Pointers, Sort | |||

525 | 34.5% | Medium | Hash Table | |||

526 | 53.4% | Medium | Backtracking | |||

527 | 34.1% | Hard | Y | |||

529 | 51.8% | Medium | Depth-First Search, Breadth-First Search | |||

530 | 48.2% | Easy | Binary Search Tree | |||

531 | 50.4% | Medium | Y | |||

532 | 27.2% | Easy | Two Pointers, Array | |||

533 | 38.9% | Medium | ||||

535 | 75.9% | Medium | Hash Table, Math | |||

536 | 36.6% | Medium | Y | |||

537 | 66.3% | Medium | Math, String | |||

538 | 52.6% | Medium | Tree | |||

539 | 44.8% | Medium | String | |||

541 | 44.4% | Easy | String | |||

542 | 32.5% | Medium | Depth-First Search, Breadth-First Search | |||

543 | 42.6% | Easy | Tree | |||

544 | 73.2% | Medium | Y | |||

545 | 23.6% | Medium | Y | |||

546 | 21.3% | Hard | Dynamic Programming, Depth-First Search | |||

# Category: leetcode

# 277. (Locked)Find the Celebrity

**Difficulty: Medium**

**Frequency: N/A**

Suppose you are at a party with `n`

people (labeled from `0`

to `n - 1`

) and among them, there may exist one celebrity. The definition of a celebrity is that all the other `n - 1`

people know him/her but he/she does not know any of them.

Now you want to find out who the celebrity is or verify that there is not one. The only thing you are allowed to do is to ask questions like: “Hi, A. Do you know B?” to get information of whether A knows B. You need to find out the celebrity (or verify there is not one) by asking as few questions as possible (in the asymptotic sense).

You are given a helper function `bool knows(a, b)`

which tells you whether A knows B. Implement a function`int findCelebrity(n)`

, your function should minimize the number of calls to `knows`

.

**Note**: There will be exactly one celebrity if he/she is in the party. Return the celebrity’s label if there is a celebrity in the party. If there is no celebrity, return `-1`

.

**Test Cases:**

**Solution 1:**

**Data structure:**

**Steps:**

**Complexity:**

**Code:**

// Forward declaration of the knows API. bool knows(int a, int b); class Solution { public: int findCelebrity(int n) { if (n <= 1) return n; int cand = 0; for (int i = 1; i < n; i++) { if (!know(i, cand) { cand = i; } } for (int j = 0; j < n; j++) { if (j == cand) continue; if (!know(j, cand) || know(cand, j)) return -1; } return cand; } };

**Solution 2:**

**Data structure:**

**steps:**

**Complexity**:

**Code**:

**Submission errors:**

**Things to learn:**

# 289. Game of Life

**Difficulty: Medium**

**Frequency: N/A**

According to the Wikipedia’s article: “The **Game of Life**, also known simply as **Life**, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.”

Given a *board* with *m* by *n* cells, each cell has an initial state *live* (1) or *dead* (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):

- Any live cell with fewer than two live neighbors dies, as if caused by under-population.
- Any live cell with two or three live neighbors lives on to the next generation.
- Any live cell with more than three live neighbors dies, as if by over-population..
- Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

Write a function to compute the next state (after one update) of the board given its current state.

**Follow up**:

- Could you solve it in-place? Remember that the board needs to be updated at the same time: You cannot update some cells first and then use their updated values to update other cells.
- In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. How would you address these problems?

**Test Cases:**

**Solution 1:**

**Data structure:**

**Steps:**

**Complexity:**

**Code:**

class Solution { public: void gameOfLife(vector<vector<int>>& board) { int m = board.size(), n = m ? board[0].size() : 0; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { int count = 0; for (int I = max(i - 1, 0); I < min(i + 2, m); I++) { for (int J = max(j - 1, 0); J < min(j + 2, n); J++) { count += board[I][J] & 1; } } if (count == 3 || count - board[i][j] == 3) { board[i][j] |= 2; } } } for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { board[i][j] >>= 1; } } } };

**Solution 2:**

**Data structure:**

**steps:**

**Complexity**:

**Code**:

**Submission errors:**

**Things to learn:**

# 239. Sliding Window Maximum

**Difficulty: Hard**

**Frequency: N/A**

Given an array *nums*, there is a sliding window of size *k* which is moving from the very left of the array to the very right. You can only see the *k* numbers in the window. Each time the sliding window moves right by one position.

For example,

Given *nums* = `[1,3,-1,-3,5,3,6,7]`

, and *k* = 3.

Window position Max --------------- ----- [1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 5 1 3 -1 [-3 5 3] 6 7 5 1 3 -1 -3 [5 3 6] 7 6 1 3 -1 -3 5 [3 6 7] 7

Therefore, return the max sliding window as `[3,3,5,5,6,7]`

.

**Note: **

You may assume *k* is always valid, ie: 1 ≤ k ≤ input array’s size for non-empty array.

**Follow up:**

Could you solve it in linear time?

**Hint:**

- How about using a data structure such as deque (double-ended queue)?
- The queue size need not be the same as the window’s size.
- Remove redundant elements and the queue should store only elements that need to be considered.

**Test Cases:**

**Solution 1:**

**Data structure:**

**Steps:**

**Complexity:**

**Code:**

class Solution { public: vector<int> maxSlidingWindow(vector<int>& nums, int k) { deque<int> dq; vector<int> results; for (int i = 0; i < nums.size(); i++) { if (!dq.empty() && dq.front() == i - k) dq.pop_front(); while (!dq.empty() && nums[dq.back()] < nums[i]) { dq.pop_back(); } dq.push_back(i); if (i >= k - 1) { results.push_back(nums[dq.front()]); } } return results; } };

**Solution 2:**

**Data structure:**

**steps:**

**Complexity**:

**Code**:

**Submission errors:**

**Things to learn:**

# 229. Majority Element II

**Difficulty: Medium**

**Frequency: N/A**

Given an integer array of size *n*, find all elements that appear more than `⌊ n/3 ⌋`

times. The algorithm should run in linear time and in O(1) space.

**Hint:**

- How many majority elements could it possibly have?
- Do you have a better hint? Suggest it!

**Test Cases:**

**Solution 1:**

**Data structure:**

**Steps:**

**Complexity:**

**Code:**

class Solution { public: vector<int> majorityElement(vector<int>& nums) { int cnt1 = 0, cnt2 = 0, a = 0, b = 1; for (int n : nums) { if (a == n) cnt1++; else if (b == n) cnt2++; else if (cnt1 == 0) { a = n; cnt1 = 1; } else if (cnt2 == 0) { b = n; cnt2 = 1; } else { cnt1--; cnt2--; } } cnt1 = cnt2 = 0; for (int n : nums) { if (n == a) cnt1++; else if (n == b) cnt2++; } vector<int> results; if (cnt1 > nums.size() / 3) results.push_back(a); if (cnt2 > nums.size() / 3) results.push_back(b); return results; } };

**Solution 2:**

**Data structure:**

**steps:**

**Complexity**:

**Code**:

**Submission errors:**

**Things to learn:**

# 218. The Skyline Problem

**Difficulty: Hard**

**Frequency: N/A**

A city’s skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you are **given the locations and height of all the buildings** as shown on a cityscape photo (Figure A), write a program to **output the skyline** formed by these buildings collectively (Figure B).

The geometric information of each building is represented by a triplet of integers `[Li, Ri, Hi]`

, where `Li`

and `Ri`

are the x coordinates of the left and right edge of the ith building, respectively, and `Hi`

is its height. It is guaranteed that `0 ≤ Li, Ri ≤ INT_MAX`

, `0 < Hi ≤ INT_MAX`

, and `Ri - Li > 0`

. You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.

For instance, the dimensions of all buildings in Figure A are recorded as: `[ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] `

.

The output is a list of “**key points**” (red dots in Figure B) in the format of `[ [x1,y1], [x2, y2], [x3, y3], ... ]`

that uniquely defines a skyline. **A key point is the left endpoint of a horizontal line segment**. Note that the last key point, where the rightmost building ends, is merely used to mark the termination of the skyline, and always has zero height. Also, the ground in between any two adjacent buildings should be considered part of the skyline contour.

For instance, the skyline in Figure B should be represented as:`[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ]`

.

**Notes:**

- The number of buildings in any input list is guaranteed to be in the range
`[0, 10000]`

. - The input list is already sorted in ascending order by the left x position
`Li`

. - The output list must be sorted by the x position.
- There must be no consecutive horizontal lines of equal height in the output skyline. For instance,
`[...[2 3], [4 5], [7 5], [11 5], [12 7]...]`

is not acceptable; the three lines of height 5 should be merged into one in the final output as such:`[...[2 3], [4 5], [12 7], ...]`

**Test Cases:**

**Solution 1:**

**Data structure:**

**Steps:**

**Complexity:**

**Code:**

class Solution { public: vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) { multimap<int, int> coords; for (auto& b : buildings) { coords.emplace(b[0], b[2]); coords.emplace(b[1], -b[2]); } multiset<int> heights = {0}; vector<pair<int, int>> corners; int x = -1, y = 0; for (auto& p : coords) { if ((x >= 0) && (p.first != x) && (corners.empty() || corners.rbegin()->second != y)) { corners.emplace_back(x, y); } if (p.second >= 0) { heights.insert(p.second); } else { heights.erase(heights.find(-p.second)); } x = p.first; y = *heights.rbegin(); } if ((!corners.empty()) && (corners.rbegin()->second != 0)) { corners.emplace_back(x, 0); } return corners; } };

**Solution 2:**

**Data structure:**

**steps:**

**Complexity**:

**Code**:

**Submission errors:**

**Things to learn:**

# 126. Word Ladder II

**Difficulty: Hard**

**Frequency: N/A**

Given two words (*beginWord* and *endWord*), and a dictionary’s word list, find all shortest transformation sequence(s) from *beginWord* to *endWord*, such that:

- Only one letter can be changed at a time
- Each intermediate word must exist in the word list

For example,

Given:

*beginWord* = `"hit"`

*endWord* = `"cog"`

*wordList* = `["hot","dot","dog","lot","log"]`

Return

[ ["hit","hot","dot","dog","cog"], ["hit","hot","lot","log","cog"] ]

**Note:**

- All words have the same length.
- All words contain only lowercase alphabetic characters.

**Test Cases:**

**Solution 1:**

**Data structure:**

**Steps:**

**Complexity:**

**Code:**

class Solution { public: vector<vector<string>> findLadders(string beginWord, string endWord, unordered_set<string> &wordList) { m.clear(); results.clear(); path.clear(); wordList.insert(beginWord); wordList.insert(endWord); unordered_set<string> cur_lev; cur_lev.insert(beginWord); unordered_set<string> next_lev; path.push_back(endWord); while (true) { // delete previous level words for (auto it = cur_lev.begin(); it != cur_lev.end(); it++) { wordList.erase(*it); } // find current level words for (auto it = cur_lev.begin(); it != cur_lev.end(); it++) { findDict(*it, wordList, next_lev); } if (next_lev.empty()) { return results; } // if find endWord if (next_lev.find(endWord) != wordList.end()) { output(beginWord, endWord); return results; } cur_lev.clear(); cur_lev = next_lev; next_lev.clear(); } return results; } private: unordered_map<string, vector<string>> m; vector<vector<string>> results; vector<string> path; void findDict(string word, unordered_set<string>& wordList, unordered_set<string>& next_level) { int n = word.size(); string s = word; for (int i = 0; i < n; i++) { s = word; for (int j = 0; j < 26; j++) { s[i] = 'a' + j; if (wordList.find(s) != wordList.end()) { next_level.insert(s); m[s].push_back(word); } } } } void output(string& start, string last) { if (last == start) { reverse(path.begin(), path.end()); results.push_back(path); reverse(path.begin(), path.end()); } else { for (int i = 0; i < m[last].size(); i++) { path.push_back(m[last][i]); output(start, m[last][i]); path.pop_back(); } } } };

**Solution 2:**

**Data structure:**

**steps:**

**Complexity**:

**Code**:

**Submission errors:**

**Things to learn:**