LeetCode Trainer

Abacus-style article library
Website made by wuisabel-gif · Original C++ code by keineahnung2345
858 ArticlesC++Markdown
LC

LeetCode library

All markdown articles, rebuilt as a website

Search the generated articles or open any problem page. Each page keeps the abacus-trainer standard: parchment sheet, stamps, tabbed article/code/review panels, and notebook-style C++.

858 shown
01
2. Add Two Numbers
straightforward implementation
02
3. Longest Substring Without Repeating Characters
sliding window
03
4. Median of Two Sorted Arrays
binary search, two pointers
04
5. Longest Palindromic Substring
dynamic programming, two pointers
05
6. ZigZag Conversion
straightforward implementation
06
9. Palindrome Number
straightforward implementation
07
10. Regular Expression Matching
DFS + memoization, dynamic programming
08
13. Roman to Integer
two pointers, sliding window
09
14. Longest Common Prefix
binary search, two pointers
10
17. Letter Combinations of a Phone Number
backtracking
11
19. Remove Nth Node From End of List
straightforward implementation
12
20. Valid Parentheses
two pointers, stack
13
21. Merge Two Sorted Lists
straightforward implementation
14
22. Generate Parentheses
two pointers, backtracking
15
23. Merge k Sorted Lists
heap / priority queue
16
24. Swap Nodes in Pairs
straightforward implementation
17
25. Reverse Nodes in k-Group
straightforward implementation
18
27. Remove Element
straightforward implementation
19
30. Substring with Concatenation of All Words
straightforward implementation
20
31. Next Permutation
greedy
21
32. Longest Valid Parentheses
dynamic programming, two pointers
22
33. Search in Rotated Sorted Array
binary search, sliding window
23
34. Find First and Last Position of Element in Sorted Array
binary search, two pointers
24
35. Search Insert Position
two pointers
25
37. Sudoku Solver
bit manipulation, backtracking
26
38. Count and Say
straightforward implementation
27
39. Combination Sum
backtracking
28
40. Combination Sum II
backtracking, greedy
29
41. First Missing Positive
greedy
30
42. Trapping Rain Water
two pointers, stack
31
43. Multiply Strings
straightforward implementation
32
44. Wildcard Matching
dynamic programming, greedy
33
45. Jump Game II
dynamic programming, greedy
34
46. Permutations
backtracking
35
47. Permutations II
backtracking, greedy
36
48. Rotate Image
straightforward implementation
37
49. Group Anagrams
greedy
38
50. Pow(x, n)
straightforward implementation
39
51. N-Queens
backtracking
40
52. N-Queens II
backtracking
41
53. Maximum Subarray
straightforward implementation
42
55. Jump Game
graph traversal, dynamic programming
43
56. Merge Intervals
stack, greedy
44
57. Insert Interval
straightforward implementation
45
58. Length of Last Word
straightforward implementation
46
59. Spiral Matrix II
straightforward implementation
47
60. Permutation Sequence
backtracking
48
61. Rotate List
straightforward implementation
49
62. Unique Paths
dynamic programming
50
63. Unique Paths II
dynamic programming
51
64. Minimum Path Sum
graph traversal, dynamic programming
52
65. Valid Number
straightforward implementation
53
66. Plus One
straightforward implementation
54
67. Add Binary
straightforward implementation
55
68. Text Justification
straightforward implementation
56
69. Sqrt(x)
binary search, two pointers
57
70. Climbing Stairs
dynamic programming
58
72. Edit Distance
dynamic programming
59
73. Set Matrix Zeroes
straightforward implementation
60
74. Search a 2D Matrix
two pointers
61
75. Sort Colors
two pointers, sliding window
62
77. Combinations
backtracking
63
78. Subsets
bit manipulation, backtracking
64
79. Word Search
graph traversal
65
80. Remove Duplicates from Sorted Array II
straightforward implementation
66
81. Search in Rotated Sorted Array II
binary search, two pointers
67
82. Remove Duplicates from Sorted List II
straightforward implementation
68
83. Remove Duplicates from Sorted List
straightforward implementation
69
84. Largest Rectangle in Histogram
dynamic programming, two pointers
70
85. Maximal Rectangle
dynamic programming, two pointers
71
86. Partition List
straightforward implementation
72
87. Scramble String
backtracking
73
88. Merge Sorted Array
straightforward implementation
74
89. Gray Code
bit manipulation, backtracking
75
90. Subsets II
backtracking, greedy
76
91. Decode Ways
DFS + memoization, dynamic programming
77
92. Reverse Linked List II
straightforward implementation
78
93. Restore IP Addresses
backtracking
79
94. Binary Tree Inorder Traversal
two pointers, stack
80
95. Unique Binary Search Trees II
dynamic programming, two pointers
81
96. Unique Binary Search Trees
binary search, two pointers
82
97. Interleaving String
DFS + memoization, dynamic programming
83
98. Validate Binary Search Tree
two pointers, stack
84
99. Recover Binary Search Tree
two pointers, sliding window
85
100. Same Tree
graph traversal, two pointers
86
102. Binary Tree Level Order Traversal
two pointers, sliding window
87
103. Binary Tree Zigzag Level Order Traversal
two pointers, stack
88
105. Construct Binary Tree from Preorder and Inorder Traversal
two pointers, sliding window
89
106. Construct Binary Tree from Inorder and Postorder Traversal
two pointers, sliding window
90
107. Binary Tree Level Order Traversal II
two pointers, sliding window
91
109. Convert Sorted List to Binary Search Tree
binary search, two pointers
92
110. Balanced Binary Tree
two pointers
93
111. Minimum Depth of Binary Tree
two pointers
94
112. Path Sum
two pointers
95
113. Path Sum II
two pointers, backtracking
96
114. Flatten Binary Tree to Linked List
two pointers, sliding window
97
115. Distinct Subsequences
dynamic programming, prefix sums
98
116. Populating Next Right Pointers in Each Node
two pointers, sliding window
99
117. Populating Next Right Pointers in Each Node II
two pointers, sliding window
100
118. Pascal's Triangle
straightforward implementation
101
119. Pascal's Triangle II
straightforward implementation
102
120. Triangle
dynamic programming
103
121. Best Time to Buy and Sell Stock
greedy
104
122. Best Time to Buy and Sell Stock II
greedy
105
123. Best Time to Buy and Sell Stock III
straightforward implementation
106
124. Binary Tree Maximum Path Sum
two pointers
107
125. Valid Palindrome
straightforward implementation
108
126. Word Ladder II
graph traversal, backtracking
109
127. Word Ladder
graph traversal
110
129. Sum Root to Leaf Numbers
two pointers
111
130. Surrounded Regions
union-find, graph traversal
112
131. Palindrome Partitioning
two pointers, backtracking
113
132. Palindrome Partitioning II
heap / priority queue, dynamic programming
114
133. Clone Graph
graph traversal
115
134. Gas Station
greedy
116
135. Candy
two pointers, sliding window
117
136. Single Number
bit manipulation
118
137. Single Number II
bit manipulation
119
138. Copy List with Random Pointer
straightforward implementation
120
139. Word Break
trie, dynamic programming
121
140. Word Break II
trie, DFS + memoization
122
141. Linked List Cycle
straightforward implementation
123
142. Linked List Cycle II
straightforward implementation
124
143. Reorder List
straightforward implementation
125
144. Binary Tree Preorder Traversal
two pointers, stack
126
145. Binary Tree Postorder Traversal
two pointers, stack
127
146. LRU Cache
data structure design
128
147. Insertion Sort List
straightforward implementation
129
148. Sort List
greedy
130
149. Max Points on a Line
straightforward implementation
131
150. Evaluate Reverse Polish Notation
stack
132
151. Reverse Words in a String
straightforward implementation
133
152. Maximum Product Subarray
dynamic programming
134
153. Find Minimum in Rotated Sorted Array
binary search, two pointers
135
154. Find Minimum in Rotated Sorted Array II
binary search, two pointers
136
155. Min Stack
data structure design, stack
137
160. Intersection of Two Linked Lists
straightforward implementation
138
162. Find Peak Element
binary search, two pointers
139
164. Maximum Gap
prefix sums, greedy
140
165. Compare Version Numbers
straightforward implementation
141
167. Two Sum II - Input array is sorted
straightforward implementation
142
168. Excel Sheet Column Title
straightforward implementation
143
169. Majority Element
binary search, two pointers
144
171. Excel Sheet Column Number
straightforward implementation
145
172. Factorial Trailing Zeroes
straightforward implementation
146
173. Binary Search Tree Iterator
two pointers, stack
147
174. Dungeon Game
dynamic programming, binary search
148
179. Largest Number
greedy
149
183. Customers Who Never Order
straightforward implementation
150
187. Repeated DNA Sequences
two pointers, bit manipulation
151
188. Best Time to Buy and Sell Stock IV
dynamic programming
152
189. Rotate Array
straightforward implementation
153
190. Reverse Bits
bit manipulation
154
191. Number of 1 Bits
bit manipulation
155
198. House Robber
dynamic programming
156
199. Binary Tree Right Side View
graph traversal, two pointers
157
200. Number of Islands
union-find, graph traversal
158
201.Bitwise AND of Numbers Range
bit manipulation
159
202. Happy Number
straightforward implementation
160
203. Remove Linked List Elements
straightforward implementation
161
205. Isomorphic Strings
straightforward implementation
162
207. Course Schedule
graph traversal
163
208. Implement Trie (Prefix Tree)
data structure design, trie
164
210. Course Schedule II
straightforward implementation
165
211. Add and Search Word - Data structure design
data structure design, trie
166
212. Word Search II
trie, graph traversal
167
213. House Robber II
dynamic programming
168
214. Shortest Palindrome
two pointers
169
215. Kth Largest Element in an Array
heap / priority queue, binary search
170
216. Combination Sum III
backtracking
171
218. The Skyline Problem
heap / priority queue, binary search
172
219. Contains Duplicate II
sliding window
173
220. Contains Duplicate III
straightforward implementation
174
221. Maximal Square
dynamic programming
175
222. Count Complete Tree Nodes
two pointers, sliding window
176
224. Basic Calculator
stack
177
225. Implement Stack using Queues
data structure design
178
226. Invert Binary Tree
two pointers, sliding window
179
228. Summary Ranges
straightforward implementation
180
229. Majority Element II
straightforward implementation
181
230. Kth Smallest Element in a BST
two pointers, stack
182
231. Power of Two
straightforward implementation
183
232. Implement Queue using Stacks
data structure design, stack
184
233. Number of Digit One
dynamic programming
185
234. Palindrome Linked List
straightforward implementation
186
235. Lowest Common Ancestor of a Binary Search Tree
graph traversal, two pointers
187
236. Lowest Common Ancestor of a Binary Tree
graph traversal, binary search
188
237. Delete Node in a Linked List
straightforward implementation
189
238. Product of Array Except Self
two pointers
190
239. Sliding Window Maximum
sliding window
191
240. Search a 2D Matrix II
straightforward implementation
192
241. Different Ways to Add Parentheses
straightforward implementation
193
242. Valid Anagram
greedy
194
257. Binary Tree Paths
two pointers
195
258. Add Digits
straightforward implementation
196
260. Single Number III
bit manipulation
197
263. Ugly Number
straightforward implementation
198
264. Ugly Number II
heap / priority queue, graph traversal
199
268. Missing Number
bit manipulation
200
273. Integer to English Words
straightforward implementation
201
274. H-Index
straightforward implementation
202
275. H-Index II
two pointers
203
278. First Bad Version
binary search, two pointers
204
279. Perfect Squares
graph traversal, dynamic programming
205
282. Expression Add Operators
backtracking
206
283. Move Zeroes
straightforward implementation
207
287. Find the Duplicate Number
straightforward implementation
208
290. Word Pattern
straightforward implementation
209
292. Nim Game
dynamic programming
210
295. Find Median from Data Stream
data structure design, heap / priority queue
211
297. Serialize and Deserialize Binary Tree
two pointers, sliding window
212
299. Bulls and Cows
greedy
213
300. Longest Increasing Subsequence
dynamic programming, binary search
214
301. Remove Invalid Parentheses
stack, backtracking
215
303. Range Sum Query - Immutable
data structure design
216
307. Range Sum Query - Mutable Medium
data structure design, binary search
217
309. Best Time to Buy and Sell Stock with Cooldown
dynamic programming
218
312. Burst Balloons
dynamic programming, two pointers
219
315. Count of Smaller Numbers After Self
binary search, two pointers
220
316. Remove Duplicate Letters
stack, greedy
221
318. Maximum Product of Word Lengths
bit manipulation
222
319. Bulb Switcher
straightforward implementation
223
322. Coin Change
dynamic programming, backtracking
224
326. Power of Three
straightforward implementation
225
328. Odd Even Linked List
straightforward implementation
226
329. Longest Increasing Path in a Matrix
DFS + memoization, graph traversal
227
332. Reconstruct Itinerary
stack
228
336. Palindrome Pairs
trie, two pointers
229
337. House Robber III
DFS + memoization, dynamic programming
230
338. Counting Bits
bit manipulation
231
342. Power of Four
straightforward implementation
232
344. Reverse String
straightforward implementation
233
345. Reverse Vowels of a String
two pointers
234
347. Top K Frequent Elements
heap / priority queue, greedy
235
349. Intersection of Two Arrays
straightforward implementation
236
352. Data Stream as Disjoint Intervals
data structure design
237
354. Russian Doll Envelopes
dynamic programming, binary search
238
367. Valid Perfect Square
straightforward implementation
239
368. Largest Divisible Subset
dynamic programming, backtracking
240
374. Guess Number Higher or Lower
two pointers, sliding window
241
380. Insert Delete GetRandom O(1)
data structure design
242
382. Linked List Random Node
straightforward implementation
243
383. Ransom Note
straightforward implementation
244
387. First Unique Character in a String
straightforward implementation
245
389. Find the Difference
straightforward implementation
246
392. Is Subsequence
greedy
247
394. Decode String
stack
248
399. Evaluate Division
union-find, graph traversal
249
400. Nth Digit
straightforward implementation
250
401. Binary Watch
straightforward implementation
251
402. Remove K Digits
stack, greedy
252
403. Frog Jump
graph traversal, dynamic programming
253
404. Sum of Left Leaves
two pointers
254
405. Convert a Number to Hexadecimal
straightforward implementation
255
406. Queue Reconstruction by Height
greedy
256
409. Longest Palindrome
two pointers, greedy
257
410. Split Array Largest Sum
binary search, two pointers
258
412. Fizz Buzz
straightforward implementation
259
413. Arithmetic Slices
dynamic programming, two pointers
260
415. Add Strings
straightforward implementation
261
416. Partition Equal Subset Sum
dynamic programming, bit manipulation
262
419. Battleships in a Board
straightforward implementation
263
420. Strong Password Checker
straightforward implementation
264
421. Maximum XOR of Two Numbers in an Array
bit manipulation, greedy
265
424. Longest Repeating Character Replacement
two pointers, sliding window
266
429. N-ary Tree Level Order Traversal
two pointers, sliding window
267
430. Flatten a Multilevel Doubly Linked List
stack
268
432. All O`one Data Structure
straightforward implementation
269
434. Number of Segments in a String
straightforward implementation
270
435. Non-overlapping Intervals
greedy
271
436. Find Right Interval
greedy
272
437. Path Sum III
two pointers
273
438. Find All Anagrams in a String
sliding window, greedy
274
441. Arranging Coins
straightforward implementation
275
442. Find All Duplicates in an Array
straightforward implementation
276
443. String Compression
straightforward implementation
277
445. Add Two Numbers II
stack
278
447. Number of Boomerangs
greedy
279
448. Find All Numbers Disappeared in an Array
straightforward implementation
280
449. Serialize and Deserialize BST
two pointers, sliding window
281
450. Delete Node in a BST
two pointers, sliding window
282
451. Sort Characters By Frequency
greedy
283
452. Minimum Number of Arrows to Burst Balloons
greedy
284
453. Minimum Moves to Equal Array Elements
greedy
285
454. 4Sum II
two pointers, sliding window
286
455. Assign Cookies
greedy
287
459. Repeated Substring Pattern
straightforward implementation
288
460. LFU Cache
data structure design, heap / priority queue
289
461. Hamming Distance
bit manipulation
290
463. Island Perimeter
graph traversal
291
464. Can I Win
DFS + memoization, dynamic programming
292
468. Validate IP Address
straightforward implementation
293
470. Implement Rand10() Using Rand7()
straightforward implementation
294
472. Concatenated Words
trie, DFS + memoization
295
474. Ones and Zeroes
dynamic programming
296
476. Number Complement
bit manipulation
297
477. Total Hamming Distance
straightforward implementation
298
480. Sliding Window Median
binary search, two pointers
299
482. License Key Formatting
straightforward implementation
300
485. Max Consecutive Ones
straightforward implementation
301
486. Predict the Winner
dynamic programming
302
492. Construct the Rectangle
straightforward implementation
303
494. Target Sum
dynamic programming
304
495. Teemo Attacking
straightforward implementation
305
496. Next Greater Element I
straightforward implementation
306
497. Random Point in Non-overlapping Rectangles
straightforward implementation
307
501. Find Mode in Binary Search Tree
two pointers, sliding window
308
503. Next Greater Element II
stack
309
504. Base 7
straightforward implementation
310
506. Relative Ranks
greedy
311
509. Fibonacci Number
straightforward implementation
312
515. Find Largest Value in Each Tree Row
two pointers, sliding window
313
516. Longest Palindromic Subsequence
dynamic programming, two pointers
314
518. Coin Change 2
dynamic programming
315
520. Detect Capital
straightforward implementation
316
521. Longest Uncommon Subsequence I
straightforward implementation
317
524. Longest Word in Dictionary through Deleting
greedy
318
525. Contiguous Array
straightforward implementation
319
526. Beautiful Arrangement
dynamic programming, bit manipulation
320
528. Random Pick with Weight
binary search, two pointers
321
529. Minesweeper
graph traversal
322
530. Minimum Absolute Difference in BST
two pointers
323
532. K-diff Pairs in an Array
straightforward implementation
324
535. Encode and Decode TinyURL
straightforward implementation
325
537. Complex Number Multiplication
straightforward implementation
326
538. Convert BST to Greater Tree
two pointers, stack
327
540. Single Element in a Sorted Array
binary search, two pointers
328
541. Reverse String II
straightforward implementation
329
543. Diameter of Binary Tree
two pointers, sliding window
330
547. Friend Circles
union-find
331
551. Student Attendance Record I
straightforward implementation
332
559. Maximum Depth of N-ary Tree
stack
333
560. Subarray Sum Equals K
prefix sums
334
561. Array Partition I
greedy
335
563. Binary Tree Tilt
two pointers
336
564. Find the Closest Palindrome
straightforward implementation
337
566. Reshape the Matrix
straightforward implementation
338
567. Permutation in String
sliding window
339
572. Subtree of Another Tree
two pointers
340
576. Out of Boundary Paths
DFS + memoization, dynamic programming
341
581. Shortest Unsorted Continuous Subarray
two pointers, stack
342
583. Delete Operation for Two Strings
dynamic programming
343
589. N-ary Tree Preorder Traversal
stack
344
590. N-ary Tree Postorder Traversal
stack, sliding window
345
591. Tag Validator
stack, backtracking
346
594. Longest Harmonious Subsequence
greedy
347
598. Range Addition II
straightforward implementation
348
599. Minimum Index Sum of Two Lists
greedy
349
605. Can Place Flowers
binary search, two pointers
350
606. Construct String from Binary Tree
two pointers, stack
351
617. Merge Two Binary Trees
sliding window
352
621. Task Scheduler
heap / priority queue, greedy
353
622. Design Circular Queue
data structure design
354
628. Maximum Product of Three Numbers
greedy
355
633. Sum of Square Numbers
straightforward implementation
356
637. Average of Levels in Binary Tree
two pointers, sliding window
357
641. Design Circular Deque
data structure design
358
643. Maximum Average Subarray I
sliding window
359
645. Set Mismatch
bit manipulation, greedy
360
647. Palindromic Substrings
dynamic programming, two pointers
361
648. Replace Words
trie, prefix sums
362
650. 2 Keys Keyboard
dynamic programming
363
653. Two Sum IV - Input is a BST
two pointers, sliding window
364
654. Maximum Binary Tree
two pointers
365
657. Judge Route Circle
two pointers
366
658. Find K Closest Elements
two pointers, sliding window
367
659. Split Array into Consecutive Subsequences
straightforward implementation
368
661. Image Smoother
straightforward implementation
369
662. Maximum Width of Binary Tree
two pointers, sliding window
370
664. Strange Printer
dynamic programming
371
665. Non-decreasing Array
straightforward implementation
372
668. Kth Smallest Number in Multiplication Table
binary search
373
669. Trim a Binary Search Tree
two pointers
374
671. Second Minimum Node In a Binary Tree
two pointers, stack
375
673. Number of Longest Increasing Subsequence
dynamic programming, binary search
376
674. Longest Continuous Increasing Subsequence
sliding window
377
676. Implement Magic Dictionary
trie
378
678. Valid Parenthesis String
DFS + memoization, dynamic programming
379
679. 24 Game
backtracking
380
680. Valid Palindrome II
greedy
381
684. Redundant Connection
union-find
382
686. Repeated String Match
straightforward implementation
383
687. Longest Univalue Path
two pointers
384
690. Employee Importance
straightforward implementation
385
692. Top K Frequent Words
heap / priority queue
386
693. Binary Number with Alternating Bits
bit manipulation
387
695. Max Area of Island
graph traversal, stack
388
696. Count Binary Substrings
binary search, two pointers
389
697. Degree of an Array
two pointers
390
698. Partition to K Equal Sum Subsets
DFS + memoization, dynamic programming
391
699. Falling Squares
binary search, two pointers
392
700. Search in a Binary Search Tree
straightforward implementation
393
701. Insert into a Binary Search Tree
straightforward implementation
394
703. Kth Largest Element in a Stream
data structure design, heap / priority queue
395
704. Binary Search
straightforward implementation
396
705. Design HashSet
data structure design
397
706. Design HashMap
data structure design
398
709. To Lower Case
straightforward implementation
399
712. Minimum ASCII Delete Sum for Two Strings
dynamic programming
400
714. Best Time to Buy and Sell Stock with Transaction Fee
dynamic programming
401
717. 1-bit and 2-bit Characters
bit manipulation
402
719. Find K-th Smallest Pair Distance
heap / priority queue, binary search
403
720. Longest Word in Dictionary
trie, two pointers
404
724. Find Pivot Index
prefix sums
405
725. Split Linked List in Parts
straightforward implementation
406
728. Self Dividing Numbers
two pointers, sliding window
407
729. My Calendar I
data structure design
408
730. Count Different Palindromic Subsequences
dynamic programming, two pointers
409
731. My Calendar II
data structure design
410
733. Flood Fill
graph traversal
411
735. Asteroid Collision
stack
412
739. Daily Temperatures
stack
413
741. Cherry Pickup
DFS + memoization, dynamic programming
414
744. Find Smallest Letter Greater Than Target
straightforward implementation
415
746. Min Cost Climbing Stairs
straightforward implementation
416
747. Largest Number At Least Twice of Others
straightforward implementation
417
748. Shortest Completing Word
straightforward implementation
418
753. Cracking the Safe
graph traversal, backtracking
419
754. Reach a Number
straightforward implementation
420
762. Prime Number of Set Bits in Binary Representation
two pointers, bit manipulation
421
766. Toeplitz Matrix
two pointers, sliding window
422
767. Reorganize String
heap / priority queue, greedy
423
771. Jewels and Stones
straightforward implementation
424
773. Sliding Puzzle
graph traversal
425
778. Swim in Rising Water
heap / priority queue, graph traversal
426
780. Reaching Points
backtracking
427
783. Minimum Distance Between BST Nodes
two pointers, sliding window
428
784. Letter Case Permutation
straightforward implementation
429
786. K-th Smallest Prime Fraction
heap / priority queue, binary search
430
787. Cheapest Flights Within K Stops
heap / priority queue
431
788. Rotated Digits
straightforward implementation
432
794. Valid Tic-Tac-Toe State
straightforward implementation
433
796. Rotate String
straightforward implementation
434
797. All Paths From Source to Target
prefix sums, backtracking
435
804. Unique Morse Code Words
straightforward implementation
436
807. Max Increase to Keep City Skyline
two pointers
437
808. Soup Servings
dynamic programming
438
812. Largest Triangle Area
straightforward implementation
439
814. Binary Tree Pruning
straightforward implementation
440
819. Most Common Word
straightforward implementation
441
824. Goat Latin
straightforward implementation
442
829. Consecutive Numbers Sum
two pointers, sliding window
443
830. Positions of Large Groups
straightforward implementation
444
832. Flipping an Image
two pointers, bit manipulation
445
835. Image Overlap
straightforward implementation
446
836. Rectangle Overlap
two pointers
447
837. New 21 Game
dynamic programming, sliding window
448
838. Push Dominoes
binary search, two pointers
449
840. Magic Squares In Grid
two pointers, sliding window
450
843. Guess the Word
straightforward implementation
451
844. Backspace String Compare
stack
452
849. Maximize Distance to Closest Person
two pointers, sliding window
453
850. Rectangle Area II
binary search, two pointers
454
852. Peak Index in a Mountain Array
two pointers, sliding window
455
853. Car Fleet
greedy
456
856. Score of Parentheses
stack
457
857. Minimum Cost to Hire K Workers
heap / priority queue, greedy
458
859. Buddy Strings
straightforward implementation
459
860. Lemonade Change
straightforward implementation
460
861. Score After Flipping Matrix
two pointers, bit manipulation
461
862. Shortest Subarray with Sum at Least K
sliding window, prefix sums
462
863. All Nodes Distance K in Binary Tree
two pointers, sliding window
463
865. Smallest Subtree with all the Deepest Nodesl
two pointers, sliding window
464
867. Transpose Matrix
straightforward implementation
465
868. Binary Gap
straightforward implementation
466
869. Reordered Power of 2
backtracking
467
872. Leaf-Similar Trees
two pointers, stack
468
876. Middle of the Linked List
straightforward implementation
469
877. Stone Game
dynamic programming, two pointers
470
881. Boats to Save People
two pointers, sliding window
471
883. Projection Area of 3D Shapes
straightforward implementation
472
884. Uncommon Words from Two Sentences
straightforward implementation
473
885. Spiral Matrix III
two pointers, sliding window
474
886. Possible Bipartition
graph traversal
475
887. Super Egg Drop
DFS + memoization, dynamic programming
476
888. Fair Candy Swap
straightforward implementation
477
889. Construct Binary Tree from Preorder and Postorder Traversal
two pointers
478
890. Find and Replace Pattern
straightforward implementation
479
892. Surface Area of 3D Shapes
graph traversal
480
893. Groups of Special-Equivalent Strings
greedy
481
894. All Possible Full Binary Trees
two pointers
482
895. Maximum Frequency Stack
data structure design, stack
483
896. Monotonic Array
straightforward implementation
484
897. Increasing Order Search Tree
two pointers, stack
485
901. Online Stock Span
data structure design, stack
486
902. Numbers At Most N Given Digit Set
dynamic programming
487
905. Sort Array By Parity
straightforward implementation
488
908. Smallest Range I
straightforward implementation
489
912. Sort an Array
two pointers
490
914. X of a Kind in a Deck of Cards
straightforward implementation
491
917. Reverse Only Letters
stack
492
918. Maximum Sum Circular Subarray
dynamic programming, sliding window
493
921. Minimum Add to Make Parentheses Valid
prefix sums
494
922. Sort Array By Parity II
sliding window
495
925. Long Pressed Name
straightforward implementation
496
929. Unique Email Addresses
straightforward implementation
497
931. Minimum Falling Path Sum
dynamic programming
498
933. Number of Recent Calls
data structure design, sliding window
499
935. Knight Dialer
DFS + memoization, dynamic programming
500
937. Reorder Data in Log Files
greedy
501
938. Range Sum of BST
stack, sliding window
502
941. Valid Mountain Array
straightforward implementation
503
942. DI String Match
greedy
504
944. Delete Columns to Make Sorted
greedy
505
946. Validate Stack Sequences
stack, greedy
506
949. Largest Time for Given Digits
backtracking, greedy
507
950. Reveal Cards In Increasing Order
greedy
508
951. Flip Equivalent Binary Trees
bit manipulation
509
952. Largest Component Size by Common Factor
union-find, graph traversal
510
953. Verifying an Alien Dictionary
straightforward implementation
511
957. Prison Cells After N Days
dynamic programming, bit manipulation
512
959. Regions Cut By Slashes
union-find
513
961. N-Repeated Element in Size 2N Array
straightforward implementation
514
964. Least Operators to Express Number
DFS + memoization, graph traversal
515
965. Univalued Binary Tree
two pointers, sliding window
516
967. Numbers With Same Consecutive Differences
backtracking
517
969. Pancake Sorting
greedy
518
970. Powerful Integers
straightforward implementation
519
973. K Closest Points to Origin
greedy
520
976. Largest Perimeter Triangle
greedy
521
977. Squares of a Sorted Array
greedy
522
979. Distribute Coins in Binary Tree
two pointers
523
980. Unique Paths III
graph traversal, bit manipulation
524
981. Time Based Key-Value Store
data structure design, two pointers
525
983. Minimum Cost For Tickets
dynamic programming
526
986. Interval List Intersections
two pointers, sliding window
527
987. Vertical Order Traversal of a Binary Tree
two pointers
528
989. Add to Array-Form of Integer
straightforward implementation
529
993. Cousins in Binary Tree
two pointers
530
994. Rotting Oranges
graph traversal, two pointers
531
997. Find the Town Judge
straightforward implementation
532
998. Maximum Binary Tree II
two pointers, sliding window
533
999. Available Captures for Rook
two pointers
534
1002. Find Common Characters
straightforward implementation
535
1004. Max Consecutive Ones III
two pointers, sliding window
536
1005. Maximize Sum Of Array After K Negations Easy
straightforward implementation
537
1007. Minimum Domino Rotations For Equal Row
straightforward implementation
538
1008. Construct Binary Search Tree from Preorder Traversal
two pointers, sliding window
539
1010. Pairs of Songs With Total Durations Divisible by 60
greedy
540
1011. Capacity To Ship Packages Within D Days
two pointers
541
1012. Complement of Base 10 Integer
straightforward implementation
542
1015. Smallest Integer Divisible by K
straightforward implementation
543
1018. Binary Prefix Divisible By 5
prefix sums
544
1019. Next Greater Node In Linked List
stack
545
1020. Number of Enclaves
stack
546
1020. Partition Array Into Three Parts With Equal Sum
straightforward implementation
547
1021. Remove Outermost Parentheses
two pointers, sliding window
548
1022. Sum of Root To Leaf Binary Numbers
two pointers, stack
549
1025. Divisor Game
greedy
550
1026. Maximum Difference Between Node and Ancestor
two pointers
551
1027. Longest Arithmetic Sequence
dynamic programming
552
1028. Recover a Tree From Preorder Traversal
binary search, two pointers
553
1029. Two City Scheduling
greedy
554
1030. Matrix Cells in Distance Order
straightforward implementation
555
1032. Stream of Characters
trie
556
1033. Moving Stones Until Consecutive
straightforward implementation
557
1035. Uncrossed Lines
dynamic programming
558
1037. Valid Boomerang
straightforward implementation
559
1038. Binary Search Tree to Greater Sum Tree
two pointers
560
1039. Minimum Score Triangulation of Polygon
dynamic programming
561
1041. Robot Bounded In Circle
two pointers
562
1042. Flower Planting With No Adjacent
straightforward implementation
563
1043. Partition Array for Maximum Sum
dynamic programming, two pointers
564
1044. Longest Duplicate Substring
binary search, two pointers
565
1046. Last Stone Weight
heap / priority queue, greedy
566
1047. Remove All Adjacent Duplicates In String
straightforward implementation
567
1048. Longest String Chain
dynamic programming
568
1051. Height Checker
greedy
569
1054. Distant Barcodes
heap / priority queue
570
1071. Greatest Common Divisor of Strings
straightforward implementation
571
1072. Flip Columns For Maximum Number of Equal Rows
straightforward implementation
572
1074. Number of Submatrices That Sum to Target
dynamic programming, sliding window
573
1078. Occurrences After Bigram
straightforward implementation
574
1079. Letter Tile Possibilities
straightforward implementation
575
1089. Duplicate Zeros
straightforward implementation
576
1094. Car Pooling
greedy
577
1096. Brace Expansion II
straightforward implementation
578
1103. Distribute Candies to People
straightforward implementation
579
1104. Path In Zigzag Labelled Binary Tree
two pointers, sliding window
580
1108. Defanging an IP Address
straightforward implementation
581
1109. Corporate Flight Bookings
straightforward implementation
582
1110. Delete Nodes And Return Forest
two pointers, stack
583
1111. Maximum Nesting Depth of Two Valid Parentheses Strings
straightforward implementation
584
1114. Print in Order
straightforward implementation
585
1115. Print FooBar Alternately
straightforward implementation
586
1116. Print Zero Even Odd
straightforward implementation
587
1117. Building H2O
straightforward implementation
588
1122. Relative Sort Array
greedy
589
1123. Lowest Common Ancestor of Deepest Leaves
two pointers, sliding window
590
1128. Number of Equivalent Domino Pairs
greedy
591
1130. Minimum Cost Tree From Leaf Values
dynamic programming, binary search
592
1137. N-th Tribonacci Number
straightforward implementation
593
1140. Stone Game II
dynamic programming
594
1143. Longest Common Subsequence
dynamic programming
595
1147. Longest Chunked Palindrome Decomposition
dynamic programming, two pointers
596
1154. Day of the Year
straightforward implementation
597
1160. Find Words That Can Be Formed by Characters
straightforward implementation
598
1161. Maximum Level Sum of a Binary Tree
two pointers, sliding window
599
1163. Last Substring in Lexicographical Order
greedy
600
1170. Compare Strings by Frequency of the Smallest Character
greedy
601
1175. Prime Arrangements
straightforward implementation
602
1184. Distance Between Bus Stops
straightforward implementation
603
1185. Day of the Week
straightforward implementation
604
1189. Maximum Number of Balloons
straightforward implementation
605
1190. Reverse Substrings Between Each Pair of Parentheses
stack
606
1192. Critical Connections in a Network
straightforward implementation
607
1195. Fizz Buzz Multithreaded
straightforward implementation
608
1200. Minimum Absolute Difference
greedy
609
1207. Unique Number of Occurrences
straightforward implementation
610
1217. Play with Chips
straightforward implementation
611
1219. Path with Maximum Gold
graph traversal
612
1221. Split a String in Balanced Strings
straightforward implementation
613
1222. Queens That Can Attack the King
straightforward implementation
614
1232. Check If It Is a Straight Line
straightforward implementation
615
1235. Maximum Profit in Job Scheduling
dynamic programming
616
1237. Find Positive Integer Solution for a Given Equation
straightforward implementation
617
1238. Circular Permutation in Binary Representation
straightforward implementation
618
1247. Minimum Swaps to Make Strings Equal
straightforward implementation
619
1248. Count Number of Nice Subarrays
two pointers, sliding window
620
1249. Minimum Remove to Make Valid Parentheses
stack
621
1252. Cells with Odd Values in a Matrix
straightforward implementation
622
1255. Maximum Score Words Formed by Letters
straightforward implementation
623
1260. Shift 2D Grid
straightforward implementation
624
1261. Find Elements in a Contaminated Binary Tree
two pointers
625
1266. Minimum Time Visiting All Points
straightforward implementation
626
1268. Search Suggestions System
trie, stack
627
1275. Find Winner on a Tic Tac Toe Game
greedy
628
1277. Count Square Submatrices with All Ones
dynamic programming, two pointers
629
1278. Palindrome Partitioning III
DFS + memoization, dynamic programming
630
1281. Subtract the Product and Sum of Digits of an Integer
straightforward implementation
631
1282. Group the People Given the Group Size They Belong To
straightforward implementation
632
1284. Minimum Number of Flips to Convert Binary Matrix to Zero Matrix
straightforward implementation
633
1286. Iterator for Combination
data structure design
634
1287. Element Appearing More Than 25% In Sorted Array
straightforward implementation
635
1288. Remove Covered Intervals
two pointers, greedy
636
1289. Minimum Falling Path Sum II
dynamic programming
637
1290. Convert Binary Number in a Linked List to Integer
straightforward implementation
638
1291. Sequential Digits
straightforward implementation
639
1295. Find Numbers with Even Number of Digits
straightforward implementation
640
1296. Divide Array in Sets of K Consecutive Numbers
greedy
641
1299. Replace Elements with Greatest Element on Right Side
straightforward implementation
642
1302. Deepest Leaves Sum
two pointers, sliding window
643
1304. Find N Unique Integers Sum up to Zero
straightforward implementation
644
1305. All Elements in Two Binary Search Trees
two pointers, stack
645
1306. Jump Game III
graph traversal, two pointers
646
1309. Decrypt String from Alphabet to Integer Mapping
straightforward implementation
647
1310. XOR Queries of a Subarray
dynamic programming, two pointers
648
1314. Matrix Block Sum
dynamic programming, two pointers
649
1315. Sum of Nodes with Even-Valued Grandparent
two pointers, stack
650
1317. Convert Integer to the Sum of Two No-Zero Integers
straightforward implementation
651
1318. Minimum Flips to Make a OR b Equal to c
bit manipulation
652
1323. Maximum 69 Number
straightforward implementation
653
1325. Delete Leaves With a Given Value
two pointers, stack
654
1329. Sort the Matrix Diagonally
greedy
655
1331. Rank Transform of an Array
greedy
656
1332. Remove Palindromic Subsequences
straightforward implementation
657
1337. The K Weakest Rows in a Matrix
heap / priority queue
658
1338. Reduce Array Size to The Half
greedy
659
1340. Jump Game V
DFS + memoization, graph traversal
660
1343. Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold
straightforward implementation
661
1344. Angle Between Hands of a Clock
straightforward implementation
662
1345. Jump Game IV
graph traversal
663
1346. Check If N and Its Double Exist
straightforward implementation
664
1347. Minimum Number of Steps to Make Two Strings Anagram
straightforward implementation
665
1349. Maximum Students Taking Exam
dynamic programming, two pointers
666
1356. Sort Integers by The Number of 1 Bits
bit manipulation, greedy
667
1359. Count All Valid Pickup and Delivery Options
straightforward implementation
668
1360. Number of Days Between Two Dates
straightforward implementation
669
1361. Validate Binary Tree Nodes
straightforward implementation
670
1362. Closest Divisors
straightforward implementation
671
1365. How Many Numbers Are Smaller Than the Current Number
greedy
672
1374. Generate a String With Characters That Have Odd Counts
straightforward implementation
673
1375. Bulb Switcher III
straightforward implementation
674
1376. Time Needed to Inform All Employees
stack
675
1377. Frog Position After T Seconds
graph traversal
676
1380. Lucky Numbers in a Matrix
straightforward implementation
677
1381. Design a Stack With Increment Operation
data structure design
678
1382. Balance a Binary Search Tree
binary search
679
1383. Maximum Performance of a Team
heap / priority queue, backtracking
680
1385. Find the Distance Value Between Two Arrays
straightforward implementation
681
1386. Cinema Seat Allocation
binary search, two pointers
682
1387. Sort Integers by The Power Value
heap / priority queue
683
1388. Pizza With 3n Slices
dynamic programming, two pointers
684
1389. Create Target Array in the Given Order
straightforward implementation
685
1390. Four Divisors
straightforward implementation
686
1391. Check if There is a Valid Path in a Grid
union-find, graph traversal
687
1392. Longest Happy Prefix
prefix sums
688
1394. Find Lucky Integer in an Array
straightforward implementation
689
1395. Count Number of Teams
two pointers, sliding window
690
1396. Design Underground System
data structure design
691
1397. Find All Good Strings
DFS + memoization, dynamic programming
692
1399. Count Largest Group
straightforward implementation
693
1400. Construct K Palindrome Strings
bit manipulation
694
1401. Circle and Rectangle Overlapping
straightforward implementation
695
1402. Reducing Dishes
greedy
696
1403. Minimum Subsequence in Non-Increasing Order
heap / priority queue, greedy
697
1404. Number of Steps to Reduce a Number in Binary Representation to One
straightforward implementation
698
1405. Longest Happy String
straightforward implementation
699
1406. Stone Game III
dynamic programming
700
1408. String Matching in an Array
prefix sums, greedy
701
1409. Queries on a Permutation With Key
straightforward implementation
702
1410. HTML Entity Parser
trie
703
1411. Number of Ways to Paint N × 3 Grid
straightforward implementation
704
1413. Minimum Value to Get Positive Step by Step Sum
straightforward implementation
705
1414. Find the Minimum Number of Fibonacci Numbers Whose Sum Is K
greedy
706
1415. The k-th Lexicographical String of All Happy Strings of Length n
backtracking
707
1416. Restore The Array
dynamic programming, prefix sums
708
1417. Reformat The String
straightforward implementation
709
1418. Display Table of Food Orders in a Restaurant
straightforward implementation
710
1419. Minimum Number of Frogs Croaking
straightforward implementation
711
1420. Build Array Where You Can Find The Maximum Exactly K Comparisons
dynamic programming, prefix sums
712
1422. Maximum Score After Splitting a String
two pointers
713
1423. Maximum Points You Can Obtain from Cards
dynamic programming, two pointers
714
1424. Diagonal Traverse II
greedy
715
1425. Constrained Subsequence Sum
heap / priority queue, dynamic programming
716
1431. Kids With the Greatest Number of Candies
straightforward implementation
717
1432. Max Difference You Can Get From Changing an Integer
straightforward implementation
718
1433. Check If a String Can Break Another String
greedy
719
1434. Number of Ways to Wear Different Hats to Each Other
dynamic programming, backtracking
720
1436. Destination City
straightforward implementation
721
1437. Check If All 1's Are at Least Length K Places Away
straightforward implementation
722
1438. Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit
heap / priority queue, sliding window
723
1439. Find the Kth Smallest Sum of a Matrix With Sorted Rows
heap / priority queue, greedy
724
1446. Consecutive Characters
straightforward implementation
725
1447. Simplified Fractions
straightforward implementation
726
1448. Count Good Nodes in Binary Tree
two pointers
727
1449. Form Largest Integer With Digits That Add up to Target
dynamic programming, backtracking
728
1450. Number of Students Doing Homework at a Given Time
straightforward implementation
729
1451. Rearrange Words in a Sentence
greedy
730
1452. People Whose List of Favorite Companies Is Not a Subset of Another List
greedy
731
1453. Maximum Number of Darts Inside of a Circular Dartboard
straightforward implementation
732
1460. Make Two Arrays Equal by Reversing Sub-arrays
greedy
733
1461. Check If a String Contains All Binary Codes of Size K
sliding window, bit manipulation
734
1462. Course Schedule IV
graph traversal
735
1463. Cherry Pickup II
dynamic programming, two pointers
736
1464. Maximum Product of Two Elements in an Array
greedy
737
1465. Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts
greedy
738
1466. Reorder Routes to Make All Paths Lead to the City Zero
union-find
739
1467. Probability of a Two Boxes Having The Same Number of Distinct Balls
backtracking
740
1470. Shuffle the Array
straightforward implementation
741
1471. The k Strongest Values in an Array
heap / priority queue, greedy
742
1472. Design Browser History
data structure design, stack
743
1473. Paint House III
DFS + memoization, dynamic programming
744
1475. Final Prices With a Special Discount in a Shop
stack
745
1476. Subrectangle Queries
data structure design
746
1477. Find Two Non-overlapping Sub-arrays Each With Target Sum
dynamic programming, sliding window
747
1478. Allocate Mailboxes
DFS + memoization, dynamic programming
748
1480. Running Sum of 1d Array
straightforward implementation
749
1481. Least Number of Unique Integers after K Removals
heap / priority queue, greedy
750
1482. Minimum Number of Days to Make m Bouquets
binary search, two pointers
751
1483. Kth Ancestor of a Tree Node
dynamic programming, bit manipulation
752
1491. Average Salary Excluding the Minimum and Maximum Salary
straightforward implementation
753
1492. The kth Factor of n
straightforward implementation
754
1493. Longest Subarray of 1's After Deleting One Element
sliding window
755
1494. Parallel Courses II
dynamic programming, bit manipulation
756
1496. Path Crossing
straightforward implementation
757
1497. Check If Array Pairs Are Divisible by k
greedy
758
1498. Number of Subsequences That Satisfy the Given Sum Condition
two pointers, sliding window
759
1499. Max Value of Equation
heap / priority queue
760
1502. Can Make Arithmetic Progression From Sequence
greedy
761
1503. Last Moment Before All Ants Fall Out of a Plank
two pointers, greedy
762
1504. Count Submatrices With All Ones
two pointers, stack
763
1505. Minimum Possible Integer After at Most K Adjacent Swaps On Digits
binary search, two pointers
764
1507. Reformat Date
straightforward implementation
765
1508. Range Sum of Sorted Subarray Sums
heap / priority queue, two pointers
766
1509. Minimum Difference Between Largest and Smallest Value in Three Moves
greedy
767
1510. Stone Game IV
DFS + memoization, dynamic programming
768
1512. Number of Good Pairs
straightforward implementation
769
1513. Number of Substrings With Only 1s
straightforward implementation
770
1514. Path with Maximum Probability
heap / priority queue, DFS + memoization
771
1515. Best Position for a Service Centre
two pointers
772
1518. Water Bottles
straightforward implementation
773
1519. Number of Nodes in the Sub-Tree With the Same Label
graph traversal, stack
774
1520. Maximum Number of Non-Overlapping Substrings
two pointers, greedy
775
1521. Find a Value of a Mysterious Function Closest to Target
two pointers, bit manipulation
776
1523. Count Odd Numbers in an Interval Range
straightforward implementation
777
1524. Number of Sub-arrays With Odd Sum
DFS + memoization, dynamic programming
778
1525. Number of Good Ways to Split a String
binary search, two pointers
779
1526. Minimum Number of Increments on Subarrays to Form a Target Array
binary search, two pointers
780
1528. Shuffle String
straightforward implementation
781
1529. Bulb Switcher IV
straightforward implementation
782
1530. Number of Good Leaf Nodes Pairs
DFS + memoization, graph traversal
783
1531. String Compression II
dynamic programming
784
1534. Count Good Triplets
straightforward implementation
785
1535. Find the Winner of an Array Game
straightforward implementation
786
1536. Minimum Swaps to Arrange a Binary Grid
greedy
787
1537. Get the Maximum Score
straightforward implementation
788
1539. Kth Missing Positive Number
two pointers
789
1540. Can Convert String in K Moves
straightforward implementation
790
1541. Minimum Insertions to Balance a Parentheses String
stack
791
1542. Find Longest Awesome Substring
dynamic programming, bit manipulation
792
1544. Make The String Great
stack
793
1545. Find Kth Bit in Nth Binary String
two pointers, sliding window
794
1546. Maximum Number of Non-Overlapping Subarrays With Sum Equals Target
dynamic programming, prefix sums
795
1547. Minimum Cost to Cut a Stick
DFS + memoization, dynamic programming
796
1550. Three Consecutive Odds
straightforward implementation
797
1551. Minimum Operations to Make Array Equal
straightforward implementation
798
1552. Magnetic Force Between Two Balls
binary search, two pointers
799
1553. Minimum Number of Days to Eat N Oranges
DFS + memoization, graph traversal
800
1556. Thousand Separator
straightforward implementation
801
1557. Minimum Number of Vertices to Reach All Nodes
straightforward implementation
802
1558. Minimum Numbers of Function Calls to Make Target Array
greedy
803
1559. Detect Cycles in 2D Grid
union-find, graph traversal
804
1560. Most Visited Sector in a Circular Track
straightforward implementation
805
1561. Maximum Number of Coins You Can Get
greedy
806
1562. Find Latest Group of Size M
union-find, binary search
807
1563. Stone Game V
DFS + memoization, dynamic programming
808
1566. Detect Pattern of Length M Repeated K or More Times
straightforward implementation
809
1567. Maximum Length of Subarray With Positive Product
greedy
810
1568. Minimum Number of Days to Disconnect Island
graph traversal
811
1569. Number of Ways to Reorder Array to Get Same BST
two pointers, sliding window
812
1572. Matrix Diagonal Sum
straightforward implementation
813
1573. Number of Ways to Split a String
straightforward implementation
814
1574. Shortest Subarray to be Removed to Make Array Sorted
binary search, two pointers
815
1575. Count All Possible Routes
DFS + memoization, dynamic programming
816
1576. Replace All question mark's to Avoid Consecutive Repeating Characters
straightforward implementation
817
1577. Number of Ways Where Square of Number Is Equal to Product of Two Numbers
straightforward implementation
818
1578. Minimum Deletion Cost to Avoid Repeating Letters
straightforward implementation
819
1579. Remove Max Number of Edges to Keep Graph Fully Traversable
union-find, greedy
820
1582. Special Positions in a Binary Matrix
straightforward implementation
821
1583. Count Unhappy Friends
straightforward implementation
822
1584. Min Cost to Connect All Points
union-find, heap / priority queue
823
1585. Check If String Is Transformable With Substring Sort Operations
straightforward implementation
824
1588. Sum of All Odd Length Subarrays
straightforward implementation
825
1589. Maximum Sum Obtained of Any Permutation
two pointers, prefix sums
826
1590. Make Sum Divisible by P
backtracking
827
1591. Strange Printer II
graph traversal, two pointers
828
1592. Rearrange Spaces Between Words
straightforward implementation
829
1593. Split a String Into the Max Number of Unique Substrings
backtracking
830
1594. Maximum Non Negative Product in a Matrix
DFS + memoization, dynamic programming
831
1595. Minimum Cost to Connect Two Groups of Points
DFS + memoization, graph traversal
832
1598. Crawler Log Folder
stack
833
1599. Maximum Profit of Operating a Centennial Wheel
straightforward implementation
834
1600. Throne Inheritance
data structure design, stack
835
1601. Maximum Number of Achievable Transfer Requests
graph traversal, backtracking
836
1603. Design Parking System
data structure design
837
1604. Alert Using Same Key-Card Three or More Times in a One Hour Period
greedy
838
1605. Find Valid Matrix Given Row and Column Sums
greedy
839
1606. Find Servers That Handled Most Number of Requests
heap / priority queue
840
1608. Special Array With X Elements Greater Than or Equal X
greedy
841
1609. Even Odd Tree
two pointers, sliding window
842
1610. Maximum Number of Visible Points
greedy
843
1611. Minimum One Bit Operations to Make Integers Zero
graph traversal, bit manipulation
844
1614. Maximum Nesting Depth of the Parentheses
stack
845
1615. Maximal Network Rank
greedy
846
1616. Split Two Strings to Make Palindrome
prefix sums, greedy
847
1617. Count Subtrees With Max Distance Between Cities
graph traversal
848
1619. Mean of Array After Removing Some Elements
greedy
849
1620. Coordinate With Maximum Network Quality
heap / priority queue, two pointers
850
1624. Largest Substring Between Two Equal Characters
straightforward implementation
851
1625. Lexicographically Smallest String After Applying Operations Medium
DFS + memoization, graph traversal
852
1626. Best Team With No Conflicts
dynamic programming, backtracking
853
1627. Graph Connectivity With Threshold
union-find, graph traversal
854
Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree
two pointers, backtracking
855
Counting Elements
straightforward implementation
856
First Unique Number
straightforward implementation
857
Leftmost Column with at Least a One
binary search, two pointers
858
Perform String Shifts
straightforward implementation