CS_BASICS

pic_source

Star History Chart

Cmd

bash
# 1) (claude code) add time, space complexity to java class
claude

/add-time-space BinarySearch
/add-time-space BFS

# ....

Resource

Algorithms content

Database

Shell


Progress

Note tags

The Note column of every problem table carries three kinds of tag, all written by script/fix_readme_tags.py from vendored data — so fix the data, not the row:

Tag Means Source
array, dp, two pointers, … the technique the row is filed under, plus LeetCode’s own topics for it data/lc_topic_tags.json
fb, amazon, apple, netflix, google (FAANG), plus microsoft, uber, linkedin, bloomberg companies known to ask it data/company_lc_tags.json
blind75, neetcode150, neetcode250, top100liked the curated lists it sits on data/problem_lists.json

The three NeetCode lists nest, so a row names only the narrowest one it is on: blind75 already implies NeetCode 150 and 250, and neetcode150 implies 250. top100liked is LeetCode’s own list and cuts across all three, so it stands on its own. NeetCode’s full 972-problem catalogue is deliberately not tagged — it would mark 607 rows without saying which to do first.

bash
python3 script/fix_readme_tags.py --report   # what would change
python3 script/fix_readme_tags.py            # rewrite the Note column

Data Structure

# Title Solution Use case Comment Status
Linear
Array Py AGAIN*
Queue Py (array), Py (linkedlist), JS AGAIN*
Stack Py, JS (linkedlist), JS (array) OK
Hash table Py, JS usually for improving time complexity B(O) via extra space complexity (time-space tradeoff) good basic AGAIN****
Linear, Pointer
LinkedList Py, JS, Java OK**
Doubly LinkedList Python, JS AGAIN
Non Linear, Pointer
Tree Py AGAIN**
Binary search Tree (BST) Python, JS, Java AGAIN
Binary Tree Py AGAIN**
Trie Py AGAIN
Heap heap.py, MinHeap.py, MaxHeap.py, MinHeap.java, MaxHeap.java AGAIN
Priority Queue (PQ) Py 1, Py 2, Py 3 AGAIN
Graph
Graph Py, JS. Java1, Java2 OK***
DirectedEdge Java AGAIN

Algorithm

# Title Solution Use case Comment Time complexity Space complexity Status
Binary search Python complexity ref Best : O(1), Avg : O(log N), Worst : O(log N) AGAIN
Linear search Python AGAIN
Breadth-first search (BFS) Python FIND SHORTEST PATH AGAIN***
Depth-first search (DFS) Python TO CHECK IF SOMETHING EXIST inorder, postorder, postorder (can recreate a tree) Adjacency List: O(V+E), Adjacency Matrix: O(V^2) O(V) (V:Vertices, E:Edges) AGAIN***
Bubble sort Python OK* (3)
Insertion sort Python, InsertionSort.java stable sort work very fast for nearly sorted array Best :O(n), Average : O(n^2), Worst : O(n^2) Worst : O(1) AGAIN
Bucket sort Python, BucketSort.java AGAIN
Quick sort quick_sort.py, quick_sort_v2.py, QuickSort.java, QuickSortV2.java, QuickSortV3.java NOTE !!!, avg is NLogN, worst is N**2, big O ref, big O ref 2 Best : O(N Log N), Avg : O(N Log N), Worst : O(N^2) AGAIN***
Heap sort Python big O ref Best : O(N Log N), Avg : O(N Log N), Worst : O(N Log N) AGAIN**
Merge sort merge_sort.py, merge_sort_topdown.py, mergesort_bottomup.py, MergeSortTopDown.java, MergeSort.java SQL Best : O(N Log N), Avg : O(N Log N), Worst : O(N Log N) O(N) OK* (2)
Pancake sort Python AGAIN
Selection sort Python, JS AGAIN
Topological sort Python, Java, Java V2 Topological Sort is a algorithm can find “ordering” on an “order dependency” graph AGAIN
md5 Python AGAIN
Union Find Python 1, Python 2, Java 1, Java 2, Java 3 AGAIN
Dynamic programming JS 1, fibonacci_dp JS AGAIN
Dijkstra Python,Java 1, Java 2 AGAIN***
Floyd-Warshall Python, Java 1, Java 2 LC 2642 not start
Bellman-Ford Python not start
Quick Find Python, Java init : O(N), union : O(N), find : O(1) simple, but slow AGAIN
Quick Union Java, Java v2 init : O(N), union : O(N), find : O(N) lazy approach, route compression, optimized Quick Find AGAIN
Quick Union (Improvements) lazy approach, path compression AGAIN
Priority Queue (unsorted) Java AGAIN
LRU cache Python LC 146 AGAIN
LFU Cache Python LC 460 AGAIN
DifferenceArray Java LC 1109, 370 AGAIN
Kadane Algo Java LC 53, 152,918 AGAIN
Patience sorting (LIS) Python longest increasing subsequence in O(N log N), longest chainable run cheatsheet, the pile count is the LIS length (Dilworth), LC 300, 334, 354, 1964, 1713 O(N log N) O(N) not start

Array

# Title Solution Time Space Difficulty Note Status
0004 Median of Two Sorted Arrays Python, Java O(log(min(m, n))) O(1) Hard binary search, binary search on partition, median, heapq (brute), amazon, google, apple, fb, microsoft, uber, linkedin, bloomberg, neetcode150, top100liked AGAIN* (1)
0015 3 Sum Python, Java O(n^2) O(1) Medium two pointers, good basic, check with # 001 Two Sum, #018 4 sum, amazon, fb, google, apple, microsoft, uber, bloomberg, blind75, top100liked OK******* (7)
0016 3 Sum Closest Python, Java O(n^2) O(1) Medium two pointers, basic, good trick, 3 sum, google, fb, apple, microsoft, goldman sachs, amazon, uber, bloomberg AGAIN******* (3)
0018 4 Sum Python, Java O(n^3) O(1) Medium two pointers, k sum, check #016 3 sum, # 454 4 SUM II, good trick, fb, google, amazon, apple, microsoft, neetcode250 AGAIN******** (4)
0026 Remove Duplicates from Sorted Array Python, Scala, Java O(n) O(1) Easy two pointers, MUST, basic, good trick, microsoft, fb, google, amazon, apple, uber, neetcode250 AGAIN************** (11)
0027 Remove Element Python, Java O(n) O(1) Easy two pointers, MUST, amazon, google, fb, apple, microsoft, uber, neetcode250 AGAIN****** (2)(MUST)
0031 Next Permutation Python, Scala, Java O(n) O(1) Medium array, good trick, 2 pointers, uber, goldman sachs, google, amazon, fb, apple, microsoft, bloomberg, top100liked AGAIN****************** (9) (MUST)
0041 First Missing Positive Python, Java O(n) O(1) Hard array, good trick, hash key, amazon, fb, google, apple, uber, microsoft, bloomberg, neetcode250, top100liked OK** (2)
0048 Rotate Image Python, Java O(n^2) O(1) Medium array, basic, i, j->j, i transpose matrix, garena, amazon, apple, google, fb, microsoft, uber, bloomberg, blind75, top100liked AGAIN************* (5) (MUST)
0054 Spiral Matrix Python, Java O(m * n) O(1) Medium array, good basic, array boundary, matrix, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN**** (4)
0056 Merge Intervals Python, Java O(nlogn) O(n) Medium interval, good trick, 057 Insert Interval, twitter, microsoft, uber, google, amazon, fb, apple, linkedin, bloomberg, blind75, top100liked, netflix OK********* (6) (but AGAIN)
0057 Insert Interval Python, Java O(n) O(n) Medium interval, good basic, 056 Merge Intervals, java array, list basic, google, amazon, fb, apple, microsoft, uber, linkedin, blind75 AGAIN********** (5) (MUST!)
0059 Spiral Matrix II Python, Java O(n^2) O(1) Medium array, check # 054 Spiral Matrix, amazon, google, fb, apple, microsoft, uber AGAIN** (2)
0066 Plus One Python, Java O(n) O(1) Easy array, basic, digit, google, amazon, fb, apple, microsoft, neetcode150 AGAIN** (3)
0073 Set Matrix Zeroes Python, Java O(m * n) O(1) Medium array, matrix, amazon, google, fb, apple, microsoft, blind75, top100liked OK* (4)
0080 Remove Duplicates from Sorted Array II Python, Java O(n) O(1) Medium array, two pointers, AGAIN, basic, trick, fb, #26 Remove Duplicates from Sorted Array, google, amazon, apple, microsoft AGAIN************ (8)
0118 Pascal’s Triangle Python, Java O(n^2) O(1) excluding output Easy array, trick, basic, google, amazon, fb, apple, microsoft, uber, bloomberg, top100liked AGAIN** (2)
0119 Pascal’s Triangle II Python, Java O(n^2) O(n) Easy array, check with # 118 Pascal's Triangle, amazon, google, microsoft OK** (4)
0121 Best Time to Buy and Sell Stock Python, Java O(n) O(1) Easy array, dp, basic, greedy, uber, microsoft, amazon, fb, google, apple, bloomberg, blind75, top100liked OK****** (7) (but again)
0157 Read N Characters Given Read4 Python, Java O(n) O(1) Easy array, 🔒, buffer, google, amazon, fb, microsoft AGAIN**** (3)
0163 Missing Ranges Python, Java O(n) O(1) Medium array, two pointer, 🔒, google, amazon, fb OK******* (4)
0169 Majority Element Python, Java O(n) O(1) Easy array, Boyer-Moore majority vote, LC 229, basic, amazon, google, fb, apple, microsoft, neetcode250, top100liked OK*
0189 Rotate Array Python, Java O(n) O(1) Medium array, k % len(nums), good basic, amazon, google, fb, apple, microsoft, bloomberg, neetcode250, top100liked OK* (7) (but again)
0209 Minimum Size Subarray Sum Python, Java O(n) O(1) Medium array, good basic, sliding window, Binary Search, trick, 2 pointers, fb, google, amazon, apple, microsoft, uber, bloomberg, neetcode250 OK********** (7) (but again)
0215 Kth Largest Element in an Array Python, Java O(n) ~ O(n^2) O(1) Medium array, EPI, quick sort, bubble sort, sort, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg, neetcode150, top100liked OK* (2)
0228 Summary Ranges Python, Java O(n) O(1) Easy array, check # 163 Missing Ranges, good basic, google, amazon, fb, microsoft, uber OK********* (5)
0229 Majority Element II Python, Java O(n) O(1) Medium array, Boyer-Moore majority vote (2 candidates), LC 169, good trick, amazon, google, apple, microsoft, bloomberg, neetcode250 OK
0238 Product of Array Except Self Python, Java O(n) O(1) Medium array, left, right array, LintCode, good trick, apple, microsoft, amazon, fb, google, uber, linkedin, blind75, top100liked OK******* (but again)(6)
0240 Search a 2D Matrix II Python, Java O(m + n) O(1) Medium array, LintCode, basic, matrix, trick, binary search, check # 74 Search a 2D Matrix, amazon, apple, google, fb, microsoft, uber, top100liked OK***** (7) (but again)
0243 Shortest Word Distance Python, Java O(n) O(1) Easy array, 🔒, basic, google, amazon, microsoft, uber, linkedin OK*
0245 Shortest Word Distance III Python, Java O(n) O(1) Medium array, 🔒, check Shortest Word Distance I II III, google, apple, microsoft, linkedin OK*
0251 Flatten 2D Vector Python, Java ctor: O(1), next: O(1) amortized O(1) Medium design, 🔒, good basic, check# 341 Flatten Nested List Iterator, google, airbnb, twitter, amazon, fb, apple, uber AGAIN******** (5)
0277 Find the Celebrity Python, Java O(n) O(1) Medium array, graph, 🔒, fb, amazon, trick, two pointers, interactive, google, apple, microsoft, uber, linkedin AGAIN********** (5)
0287 Find the Duplicate Number Python, Java O(n) O(1) Medium two pointers, good trick, Floyd cycle detection, binary search on value, check # 142 Linked List Cycle II, amazon, google, fb, apple, microsoft, uber, bloomberg, neetcode150, top100liked OK* (2)
0289 Game of Life Python, Java O(m * n) O(1) Medium array, simultaneous, matrix, complex, google, amazon, fb, apple, microsoft AGAIN*** (4)
0293 Flip Game Python, Java O(n^2) O(n) Easy array, 🔒, basic, string, google AGAIN*
0308 Range Sum Query 2D - Mutable Python, Java ctor: O(m * n), update: O(logm * logn), query: O(logm * logn) O(m * n) Hard array, LC 303, LC 304, pre-sum, binary indexed tree (BIT), segment tree, 🔒, google, fb AGAIN***** (1) (not start)
0311 Sparse Matrix Multiplication Python, Java O(m * n * l) O(m * l) Medium array, 🔒, matrix, basic, fb, google, amazon, apple, linkedin OK**** (5)
0334 Increasing Triplet Subsequence Python, Java O(n) O(1) Medium array, AGAIN, check LC 300, trick, fb, google, amazon, uber OK***** (but again) (4)
0335 Self Crossing Java O(n) O(1) Hard array, geometry, google, amazon Again (not start)
0370 Range Addition Python, Java O(k + n) O(n) Medium prefix sum, prefix, diff array, check # 598 Range Addition II, amazon, LC 1109, LC 1094, google AGAIN************** (4) (MUST)
0384 Shuffle an Array Python, Java ctor: O(n), shuffle: O(n) O(n) Medium design, EPI, trick, google, amazon, fb, apple, microsoft, uber, linkedin OK*
0396 Rotate Function Python, Java O(n) O(1) Medium array, can pass, math, trick, amazon, google, apple AGAIN*** (3)
0412 Fizz Buzz Python, Scala, Java O(n) O(1) Easy array, basic, string, simulation, LC 1195, math, google, amazon, fb, apple, microsoft, linkedin OK
0414 Third Maximum Number Python, Java O(n) O(1) Easy array, good basic, amazon, google, fb, apple, microsoft OK* (4)
0419 Battleships in a Board Python, Java O(m * n) O(1) Medium array, matrix, count only top-left cell of each ship, no extra space, LC 200, amazon, google, fb, apple, microsoft AGAIN*
0422 Valid Word Square Python, Java O(m * n) O(1) Easy array, 🔒, basic, matrix, google AGAIN*
0442 Find All Duplicates in an Array Python, Java O(n) O(1) Medium array, index-as-hash (negative marking), LC 448, LC 41, good trick, amazon, google, fb, apple, microsoft OK*
0448 Find All Numbers Disappeared in an Array Python, Java O(n) O(1) Easy array, index-as-hash (negative marking), LC 442, LC 41, good basic, google, amazon, fb, apple, microsoft OK
0498 Diagonal Traverse Python, Java O(m * n) O(1) excluding output Medium array, matrix, Diagonal, google, fb, amazon, apple, microsoft AGAIN****** (5)
0531 Lonely Pixel I Python, Java O(m * n) O(m + n) Medium array, 🔒, matrix, basic, google, microsoft AGAIN*
0533 Lonely Pixel II Python, Java O(m * n) O(m * n) Medium array, 🔒, matrix, row-pattern hashing, LC 531, google AGAIN (not start*)
0565 Array Nesting Python, Java O(n) O(1) Medium array, union find, dfs, apple, google AGAIN**** (1)
0566 Reshape the Matrix Python, Java O(m * n) O(m * n) Easy array, basic, matrix, fb AGAIN**
0581 Shortest Unsorted Continuous Subarray Python, Java O(n) O(1) Easy array, basic, google, amazon, fb, apple, microsoft, bloomberg AGAIN*
0605 Can Place Flowers Python, Java O(n) O(1) Easy array, pass vs continue, amazon, fb, apple, microsoft, linkedin OK*
0624 Maximum Distance in Arrays Python, Java O(n) O(1) Easy array, 🔒, track running max excluding the current array, good trick AGAIN*
0643 Maximum Average Subarray I Python, Java O(n) O(1) Easy array, Math, basic, google, amazon, fb AGAIN*
0661 Image Smoother Python, Java O(m * n) O(m * n) Easy array, matrix, basic, amazon, fb, apple, microsoft OK***** (4) (but again!)
0665 Non-decreasing Array Python, Java O(n) O(1) Easy array, greedy, at most one modification, decide nums[i-1] vs nums[i+1], good trick, google, amazon, fb AGAIN (not start)
0667 Beautiful Arrangement II Python, Java O(n) O(1) Medium array, math, construct k distinct diffs then run out, trick, google AGAIN (not start)
0670 Maximum Swap Python, Java O(n) O(n) Medium array, good basic, n = number of digits, last-occurrence index, string + pointers, fb, math, greedy, google, amazon, apple, microsoft AGAIN************ (9) (MUST)
0674 Longest Continuous Increasing Subsequence Python, Java O(n) O(1) Easy array, good basic, dp, 2 pointers, fb, google, amazon, apple, microsoft OK*** (5)
0697 Degree of an Array Python, Java O(n) O(n) Easy array, hash table, degree + first/last index, good basic AGAIN (not start)
0713 Subarray Product Less Than K Python, Java O(n) O(1) Medium array, basic, sliding window, good trick, google, amazon, fb, microsoft OK****** (3) (but again)
0717 1-bit and 2-bit Characters Python, Java O(n) O(1) Easy array, Greedy, google, amazon, apple AGAIN (not start)
0723 Candy Crush Python, Java O((R * C)^2) O(1) Medium array, complex, google, fb, uber, bloomberg AGAIN (not start)
0724 Find Pivot Index Python, Java O(n) O(1) Easy array, good basic, prefix-sum, google, amazon, fb, apple, microsoft, uber OK**** (2)
0729 My Calendar I Python, Java O(nlogn) O(n) Medium array, good basic, interval, google, amazon, fb, apple, microsoft AGAIN**** (1)
0731 My Calendar II Python, Java O(n^2) O(n) Medium array, trick, good trick, scanning line, google, amazon, microsoft AGAIN******** (4)
0747 Largest Number At Least Twice of Others Python, Java O(n) O(1) Easy array, good basic, data structure, google OK*
0755 Pour Water Python, Java O(v * n) O(1) Medium array, complex AGAIN (not start)
0759 Employee Free Time Python, Java O(nlogn) O(n) Hard interval, LC 56 and LC 986, heap, merger intervals, scanning line, amazon, fb, google, uber, airbnb, apple, microsoft AGAIN********** (2) (not start)
0766 Toeplitz Matrix Python, Java O(m * n) O(1) Easy array, basic, matrix, google, amazon, fb, apple AGAIN* (2)
0769 Max Chunks To Make Sorted Python, Java O(n) O(1) Medium prefix sum, LC 768, good trick, stack, array, google, greedy, amazon, microsoft, uber AGAIN*** (2)
0792 Number of Matching Subsequences Python, Java O(n + w) O(w) Medium hash table, basic, hash map, google, amazon, fb, apple AGAIN**** (2)
0794 Valid Tic-Tac-Toe State Python, Java O(1) O(1) Medium array, complex, google, amazon, fb, apple, microsoft AGAIN
0795 Number of Subarrays with Bounded Maximum Python, Java O(n) O(1) Medium array, count subarrays with max in [left, right], two pointers, trick, google, amazon, apple, microsoft AGAIN (not start*)
0807 Max Increase to Keep City Skyline Python, Java O(n^2) O(n) Medium array, matrix, row max + col max, greedy, good basic, google, amazon AGAIN*
0821 Shortest Distance to a Character Python, Java O(n) O(1) excluding output Easy array, basic, trick, google, apple AGAIN**
0830 Positions of Large Groups Python, Java O(n) O(1) Easy array, basic, string, google AGAIN*
0832 Flipping an Image Python, Java O(n^2) O(1) Easy array, matrix, reverse each row then invert, two pointers, basic, google, fb AGAIN*
0835 Image Overlap Python, Java O(n^4) O(n^2) Medium array, matrix, brute-force all shifts, count overlaps with a delta hashmap, google AGAIN (not start)
0840 Magic Squares In Grid Python, Java O(m * n) O(1) Easy array, complex, google AGAIN (not start)
0842 Split Array into Fibonacci Sequence Python, Java O(n^3) O(n) Medium array, check # 306 Addictive Number, basic, dfs, fibonacci, string, backtracking, amazon AGAIN* (not start)
0845 Longest Mountain in Array Python, Java O(n) O(1) Medium array, basic, 2 pointers expansion, google, amazon AGAIN************ (2)(MUST)
0849 Maximize Distance to Closest Person Python, Java O(n) O(1) Medium array, basic, 2 pointers, LC 855, google, amazon, microsoft AGAIN********* (2)
0860 Lemonade Change Python, Java O(n) O(1) Easy array, amazon, apple, neetcode250 OK* (2)
0868 Transpose Matrix Python, Java O(r * c) O(r * c) Easy array, basic, bit manipulation OK*
0885 Spiral Matrix III Python, Java O(max(m, n)^2) O(1) Medium array, basic, fb AGAIN* (not start)
0888 Fair Candy Swap Python, Java O(m + n) O(m + n) Easy array, basic, trick, amazon, uber OK*
0896 Monotonic Array Python, Java O(n) O(1) Easy array, all, fb, amazon OK
0905 Sort Array By Parity Python, Java O(n) O(1) Easy array, custom sort, 2 pointers, google, amazon, fb, apple, microsoft AGAIN***** (1)(MUST)
0909 Snakes and Ladders Python, Java O(n^2) O(n^2) Medium array, matrix, bfs, complex, amazon, google, apple, microsoft, uber AGAIN***** (3)
0915 Partition Array into Disjoint Intervals Python, Java O(n) O(n) Medium array, basic, trick, amazon, microsoft AGAIN* (not start)
0918 Maximum Sum Circular Subarray Python, Java O(n) O(1) Medium array, check # 053 Maximum Subarray, basic, Kadane, DP, google, amazon, fb, uber, neetcode250 AGAIN*************** (3)
0921 Minimum Add to Make Parentheses Valid Python, Java O(n) O(1) Medium array, basic, trick, string, stack, greedy, amazon, fb, microsoft AGAIN**
0922 Sort Array By Parity II Python, Java O(n) O(1) Easy array, basic, amazon, microsoft AGAIN*
0923 3Sum With Multiplicity Python, Java O(n^2) O(n) Medium array, LC 15, count pairs with a Counter, combination math, trick AGAIN (not start)
0932 Beautiful Array Python, Java O(nlogn) O(n) Medium array, divide and conquer, odd/even split, trick, google, fb AGAIN** (not start) (1)
0941 Valid Mountain Array Python, Java O(n) O(1) Easy array, basic, good basic, google, amazon, uber AGAIN*
0945 Minimum Increment to Make Array Unique Python, Java O(nlogn) O(n) Medium array, trick, good, uber AGAIN**
0947 Most Stones Removed with Same Row or Column Python, Java O(n * a(n)) O(n) Medium array, Union Find on row/col keys, dfs, trick, google, hash table, amazon, apple, uber AGAIN** (1) (not start)
0949 Largest Time for Given Digits Python, Java O(1) O(1) Easy array, brute force all 4! digit permutations, math, basic, google, amazon OK*
0950 Reveal Cards In Increasing Order Python, Java O(nlogn) O(n) Medium array, sort + deque simulation, queue, 2 pointers, google, amazon AGAIN (not start) (2)
0954 Array of Doubled Pairs Python, Java O(n + klogk) O(k) Medium array, counter, dict, trick, google, amazon, uber AGAIN**
0961 N-Repeated Element in Size 2N Array Python, Java O(n) O(1) Easy array, LC 217, hash table / count, basic, apple OK
0989 Add to Array-Form of Integer Python, Java O(n) O(1) Easy array, add xxx to sum, fb, google AGAIN (not start)
1007 Minimum Domino Rotations For Equal Row Java O(n) O(1) Medium array, google, dp, amazon, apple AGAIN (1)
1014 Best Sightseeing Pair Python, Java O(n) O(1) Medium array, dp, good basic, Spotify, google AGAIN (not start)
1027 Longest Arithmetic Subsequence Python, Java O(n^2) O(n^2) Medium array, dp, hash table, trick, google, amazon, fb, microsoft, uber AGAIN*** (not start)
1031 Maximum Sum of Two Non-Overlapping Subarrays Python, Java O(n) O(n) Medium array, prefix sum+slide window, good trick, google, amazon, fb AGAIN*************** (3)(MUST)
1041 Robot Bounded In Circle Python, Java O(n) O(1) Medium array, math, amazon, string, simulation, google, apple, microsoft AGAIN** (2)
1074 Number of Submatrices That Sum to Target Java O(m^2 * n) O(n) Hard array, hashmap, prefix sum, google, amazon, fb, apple, microsoft AGAIN (not start)
1089 Duplicate Zeros Java O(n) O(1) Easy array, two pointers, in-place shift from the back, good trick, google, amazon, microsoft AGAIN (not start)
1094 Car Pooling Python, Java O(n + k) O(k) Medium array, range addition, prefix sum, LC 370, google, amazon, fb, microsoft, neetcode250 AGAIN********** (5) (MUST)
1109 Corporate Flight Bookings Python, Java O(n + k) O(n) Medium array, LC 370, difference array, good basic, amazon, google AGAIN********* (MUST) (3)
1248 Count Number of Nice Subarrays Python, Java O(n) O(n) Medium array, card, LC 828, map, Prefix sum, exactly K with at most K, amazon AGAIN********************* (4) (MUST)
1272 Remove Interval Java O(n) O(n) Medium array, google AGAIN (not start)
1275 Find Winner on a Tic Tac Toe Game Python, Java O(1) O(1) Easy array, amazon, google, fb, apple, microsoft AGAIN (not start)
1288 Remove Covered Intervals Java O(nlogn) O(1) Medium array, greedy, interval, amazon, fb, apple AGAIN (not start)
1314 Matrix Block Sum Java O(m * n) O(m * n) Medium array, prefix sum, dp, matrix sum, google, amazon, fb, apple AGAIN (not start)
1431 Kids With the Greatest Number of Candies Java O(n) O(1) excluding output Easy array, compare each candy count with the max, basic, google, amazon, uber AGAIN (not start)
1470 Shuffle the Array Java O(n) O(1) excluding output Easy array, index mapping, 2 pointers, basic, google, amazon, apple, uber AGAIN (not start)
1564 Put Boxes Into the Warehouse I Java O(nlogn) O(m) Medium array, google AGAIN (not start)
1567 Maximum Length of Subarray With Positive Product Python, Java O(n) O(1) Medium array, good trick, dp, 2 pointers, amazon, microsoft AGAIN**** (1) (not start)
1672 Richest Customer Wealth Java O(m * n) O(1) Easy array, row sum then max, matrix, basic, google, amazon, apple, uber OK
1806 Minimum Number of Operations to Reinitialize a Permutation Java O(n) O(n) Medium array, brute force, google AGAIN (not start)
1914 Cyclically Rotating a Grid Python, Java O(m * n) O(m * n) Medium array, brute force, dequeueamazon, amazon AGAIN (not start)
1920 Build Array from Permutation Java O(n) O(1) excluding output Easy array, index mapping, basic, google, amazon, fb, apple, uber AGAIN (not start)
1929 Concatenation of Array Java O(n) O(1) excluding output Easy array, concatenate, basic, google, neetcode250 AGAIN (not start)
1991 Find the Middle Index in Array Java O(n) O(1) Easy array, prefix sum, LC 724, good basic AGAIN (not start)
2033 Minimum Operations to Make a Uni-Value Grid Python O(m * n * log(m * n)) O(m * n) Medium array, feasible iff all values agree mod x, median minimizes sum of abs deviation, sort, math, LC weekly AGAIN(1)
2075 Decode the Slanted Ciphertext Python O(n) O(n) Medium array, matrix, cols = len // rows, read diagonals from each start col, rstrip padding only, amazon AGAIN(1)
2079 Watering Plants Java O(n) O(1) Medium array, google AGAIN (not start)
2553 Separate the Digits in an Array Java O(n * d) O(1) excluding output Easy array, weekly 97 OK
2640 Find the Score of All Prefixes of an Array Java O(n) O(1) excluding output Medium array, lc weekly 102 OK (1)
2644 Find the Maximum Divisibility Score Java O(n * m) O(1) Easy array, sort Again (1)
3195 Find the Minimum Area to Cover All Ones I Java O(m * n) O(1) Medium array, LC weekly AGAIN (1)
3964 Minimum Lights to Illuminate a Road Python, Java O(n) O(n) Medium array, diff array, LC bi weekly AGAIN (1)
4052 Cyclically Shift Rows and Columns Python O(n^2) O(n^2) Easy array, matrix simulation, rows first THEN cols, write into a NEW grid (in-place overwrites unread cells), composed one-pass index as V0-1, LC weekly AGAIN(1)

Set

# Title Solution Time Space Difficulty Note Status
1316 Distinct Echo Substrings Java O(n^2) O(n^2) Hard set, set of substrings, rolling hash / Rabin-Karp for O(n^2), trick, string, trie, google Again (not start)
1436 Destination City Java O(n) O(n) Easy set, set of outgoing cities, find the city with no outgoing path, basic, google Again (1)
2357 Make Array Zero by Subtracting Equal Amounts Java O(n) O(n) Easy set, count distinct non-zero values, good trick Again (1)
2657 Find the Prefix Common Array of Two Arrays Java O(n) O(n) Medium set, frequency array + running common count, good trick, weekly_103 Again**** (1)
2682 Find the Losers of the Circular Game Java O(n) O(n) Easy set, simulate the circular jumps until a friend repeats, hashset, basic Again (1)

Slide Window

# Title Solution Time Space Difficulty Note Status
0030 Substring with Concatenation of All Words Java O(n * l) O(m * l) Hard sliding window, hashmap word count, fixed-size window of l chars, LC 76, good trick, google, amazon, fb, apple, microsoft AGAIN(not start)
0768 Max Chunks To Make Sorted II Java O(n) O(n) Hard sliding window, LC 769, prefix max vs suffix min, monotonic stack, good trick, array, greedy, google, amazon, microsoft AGAIN(not start)
1004 Max Consecutive Ones III Java O(n) O(1) Medium sliding window, longest window with at most k zeros, LC 487, LC 424, good basic, google, amazon, fb, apple, microsoft Again (1)
1423 Maximum Points You Can Obtain from Cards Python O(n) O(1) Medium slide window, window the complement: minimise the block you leave, good trick, google, amazon, apple, uber AGAIN(1)
1461 Check If a String Contains All Binary Codes of Size K Python O(n) O(2^k) Medium slide window, rolling window as an int + set, pigeonhole early exit, bit manipulation, rolling hash, google AGAIN(1)
1658 Minimum Operations to Reduce X to Zero Python, Java O(n) O(1) Medium sliding window, turn “remove from both ends” into “longest middle subarray with sum total-x”, good trick, google, amazon AGAIN******** (1)(MUST)
1838 Frequency of the Most Frequent Element Java, Python O(nlogn) O(1) Medium sliding window, sort + sliding window with sum, binary search on the answer, good trick, amazon, microsoft AGAIN******** (1)(good)
1839 Longest Substring Of All Vowels in Order Python, Java O(n) O(1) Medium sliding window, window must be non-decreasing and cover all 5 vowels, basic AGAIN** (1)(good)
1888 Minimum Number of Flips to Make The Binary String Alternating Python O(n) O(1) Medium slide window, double the string = every rotation, score both alternating targets at once, good trick, google AGAIN(1)
2555 Maximize Win From Two Segments Java O(n) O(n) Medium sliding window, best window ending at i + best window before i, prefix dp, weekly 97 AGAIN (not start)
2962 Count Subarrays Where Max Element Appears at Least K Times Java O(n) O(1) Medium sliding window, count windows containing the max at least k times, good trick, weekly 375 AGAIN************ (3)
3090 Maximum Length Substring With Two Occurrences Java O(n) O(1) Easy sliding window, longest window where every char appears at most twice, weekly 390 AGAIN (1)
4067 Longest Subarray With Restricted Pair Sums Python O(n^2) O(V) Medium sliding window, pair-sum hashmap updated incrementally, validity is monotone, only the newcomer can join a triple (O(n * V)), LC weekly AGAIN********* (1) (MUST)

Hash Table

# Title Solution Time Space Difficulty Note Status
0001 Two Sum Python, Java,Scala O(n) O(n) Easy hash table, good basic, apple, amazon, uber, grab, fb, google, microsoft, linkedin, bloomberg, blind75, top100liked OK*** (6) (but again)
0003 Longest Substring Without Repeating Characters Python, Java O(n) O(1) Medium hash table, card, 2 pointers, optimized (SLIDING WINDOW + DICT), good trick, hashMap, MUST, apple, amazon, fb, google, microsoft, uber, bloomberg, blind75, top100liked AGAIN**************** (12) (but AGAIN)
0036 Valid Sudoku Python, Java O(9^2) O(9^2) Medium hash table, array, hashset, uber, apple, amazon, google, fb, microsoft, neetcode150 OK**** (3) (again)
0049 Group Anagrams Python, Scala, Java O(n * glogg) O(n * g) Medium hash table, good basic, dict, trick, dict + sort, uber, amazon, fb, google, apple, microsoft, bloomberg, blind75, top100liked OK ********** (6)
0170 Two Sum III - Data structure design Python , Java add: O(1), find: O(n) O(n) Easy hash table, 🔒, trick, good basic, linkedin, fb OK*** (4)
0187 Repeated DNA Sequences Python , Java O(n) O(n) Medium hash table, basic, trick, set, linkedin, google, amazon, apple AGAIN**
0202 Happy Number Python , Java O(k) O(k) Easy hash table, twitter, airbnb, uber, google, amazon, fb, apple, microsoft, bloomberg, neetcode150 AGAIN** (4)
0204 Count Primes Python , Java O(nloglogn) O(n) Medium hash table, Sieve of Eratosthenes, good trick, cache, microsoft, amazon, array, math, number theory, google, apple AGAIN******** (5)
0205 Isomorphic Strings Python, Java O(n) O(1) Easy hash table, basic, trick, bloomberg, google, amazon, fb, apple, uber, linkedin AGAIN**
0217 Contains Duplicate Python , Java O(n) O(n) Easy hash table, yahoo, airbnb, google, amazon, fb, apple, microsoft, uber, blind75 OK
0219 Contains Duplicate II Python ,Java O(n) O(n) Easy hash table, basic, trick, google, amazon, fb, apple, neetcode250 AGAIN*
0244 Shortest Word Distance II Python , Java ctor: O(n), lookup: O(a + b) O(n) Medium hash table, 🔒, amazon, uber, linkedin AGAIN (not start*)
0246 Strobogrammatic Number Python, Java O(n) O(1) Easy hash table, 🔒, google, fb, microsoft OK* (5)
0249 Group Shifted Strings Python , Java O(n * l) O(n * l) Medium hash table, LC 49, 🔒, hashmap, char, apple, uber, google, amazon, fb OK *****(6) (but again)
0266 Palindrome Permutation Python , Java O(n) O(1) Easy hash table, 🔒, google, amazon, fb, microsoft, uber, bloomberg OK
0288 Unique Word Abbreviation Python , Java ctor: O(n), lookup: O(1) O(k) Medium hash table, 🔒, ?, google, fb AGAIN (2)(not start)
0290 Word Pattern Python , Java O(n) O© Easy hash table, basic, chcek # 205 Isomorphic Strings, good basic, for ptn, word in zip(pattern, words), dropbox, uber, google, amazon, fb, apple, microsoft AGAIN* (3)
0299 Bulls and Cows Python , Java O(n) O(1) Easy hash table, trick, map(operator.eq, a, b), amazon, airbnb, google AGAIN* (3)
0314 Binary Tree Vertical Order Traversal Python , Java O(n) O(n) Medium hash table, LC 987, 🔒, BFS, DFS, tree, trick, google, amazon, fb, microsoft, apple OK**** (6)
0325 Maximum Size Subarray Sum Equals k Python, Java O(n) O(n) Medium hash table, prefix sum, 🔒, hashmap, good trick, dict, fb, google, amazon, apple, microsoft AGAIN***************** (8) (MUST)
0336 Palindrome Pairs Java O(n * l^2) O(n * l) Hard hash table, LC 49, Anagrams, string op, hashmap, sub-string, google, amazon, fb, apple, uber Again******* (2)(again)
0356 Line Reflection Python , Java O(n) O(n) Medium hash table, 🔒, Hash, Two Pointers, math, google, amazon AGAIN (not start)
0359 Logger Rate Limiter Python, Java O(1), amortized O(k) Easy hash table, 🔒, google, amazon, fb, apple, microsoft, uber OK
0387 First Unique Character in a String Python , Java O(n) O(n) Easy hash table, amazon, apple, fb, google, microsoft, bloomberg OK
0388 Longest Absolute File Path Python , Java O(n) O(d) Medium hash table, stack, good trick, file system, google, string, dfs, amazon, fb, apple, uber AGAIN************* (4) (MUST)
0409 Longest Palindrome Python , Java O(n) O(1) Easy hash table, count char pairs, add 1 if any odd count remains, basic, google, amazon OK*
0424 Longest Repeating Character Replacement Python, Java O(n) O(1) Medium hash table, card, hash map, max_freq, silding window, good trick, LC blind pattern, google, amazon, fb, apple, microsoft, uber, blind75 AGAIN**************** (10) (MUST)
0438 Find All Anagrams in a String Python , Java O(n) O(1) Medium hash table, trick, AGAIN, sliding window, acc Counter, amazon, fb, apple, google, uber, yahoo, microsoft, bloomberg, top100liked AGAIN************** (11)(must)
0447 Number of Boomerangs Python , Java O(n^2) O(n) Easy hash table, trick, google AGAIN (3) (not start)
0454 4Sum II Python , Java O(n^2) O(n^2) Medium hash table, check LC 018 4SUM, trick, basic, amazon, google, fb, apple, uber AGAIN**
0463 Island Perimeter Python , Java O(m * n) O(1) Easy hash table, count cells then subtract shared edges, matrix, basic, google, fb, amazon, array, dfs, bfs, apple, microsoft, bloomberg, neetcode250 AGAIN** (2)
0470 Implement Rand10() Using Rand7() Python , Java O(1) O(1) Medium hash table, trick, google, math, apple, microsoft, uber AGAIN** (3)
0473 Matchsticks to Square Python , Java O(n * s * 2^n) O(n * (2^n + s)) Medium hash table, good trick, backtrack, array, dp, amazon, microsoft, neetcode250 AGAIN****** (2)
0523 Continuous Subarray Sum Python , Java O(n) O(k) Medium hash table, sub array sum, check # 560 Subarray Sum Equals K, good trick, substring, AGAIN, microsoft, fb, apple, google, amazon AGAIN*************** (10) (MUST)
0525 Contiguous Array Python, Java O(n) O(n) Medium hash table, card, sub-array sum, LC 560, 525, 974, good basic, array, hashmap, fb, amazon, google, apple AGAIN****************** (12) (MUST)
0532 K-diff Pairs in an Array Python , Java O(n) O(n) Medium hash table, basic, collections.Counter(), a-b =k -> a = k + b , amazon, google, fb, apple, microsoft, uber, bloomberg AGAIN********** (6)
0554 Brick Wall Python , Java O(n) O(m) Medium hash table, LC 252, gap map, trick, hash map, bloomberg, fb, grab, google AGAIN******** (6)
0560 Subarray Sum Equals K Python, Java O(n) O(n) Medium hash table, card, LC 560, 525, 974, prefix sum, must check, check # 523 Continuous Subarray Sum, LC 1268, basic, substring, good trick, google, fb, amazon, apple, microsoft, uber, bloomberg, neetcode250, top100liked AGAIN***************** (8) (MUST)
0561 Array Partition I Python , Java O(nlogn) O(1) Easy hash table, sort then sum every other element, greedy, good trick, array, amazon, apple OK
0575 Distribute Candies Python , Java O(n) O(n) Easy hash table, min(distinct kinds, n / 2), hashset, basic, microsoft OK
0594 Longest Harmonious Subsequence Python , Java O(n) O(n) Easy hash table, basic, good trick OK* (3)
0599 Minimum Index Sum of Two Lists Python , Java O((m + n) * l) O(m * l) Easy hash table, yelp, apple OK*
0609 Find Duplicate File in System Python , Java O(n * l) O(n * l) Medium hash table, collections.defaultdict(list), dropbox, google, amazon, fb, apple, microsoft OK*
0657 Robot Return to Origin Python , Java O(n) O(1) Easy hash table, amazon, string, simulation, google OK (2)
0710 Random Pick with Blacklist Java ctor: O(b), pick: O(1) O(b) Hard hash table, hashmap, google, amazon, uber AGAIN (not start)
0748 Shortest Completing Word Python , Java O(n) O(1) Easy hash table, collections.Counter, google, linkedin AGAIN* (3)
0760 Find Anagram Mappings Python , Java O(n) O(n) Easy hash table, basic, collections.defaultdict, google OK
0771 Jewels and Stones Python , Java O(m + n) O(n) Easy hash table, amazon, google, fb, apple, uber OK (2)
0811 Subdomain Visit Count Python , Java O(n) O(n) Easy hash table, indeed, bloomberg, google, amazon AGAIN (not start)
0822 Card Flipping Game Python , Java O(n) O(n) Medium hash table, good basic AGAIN* (3)
0825 Friends Of Appropriate Ages Python , Java O(a^2 + n) O(a) Medium hash table, good basic, counter, AGAIN, fb, array, two pointers, binary search AGAIN***** (5)
0869 Reordered Power of 2 Python , Java O(1) O(1) Medium hash table, trick, basic, bit manipulation, bit AGAIN*
0873 Length of Longest Fibonacci Subsequence Python , Java O(n^2) O(n) Medium hash table, trick, DP, Fibonacci, set, amazon, apple AGAIN**
0957 Prison Cells After N Days Python , Java O(1) O(1) Medium hash table, trick, DP, mod, amazon, apple AGAIN (not start)
0966 Vowel Spellchecker Python , Java O(n) O(w) Medium hash table, trick, dict, set, amazon AGAIN (not start)
0974 Subarray Sums Divisible by K Python , Java O(n) O(k) Medium hash table, LC 560, 525, 974, prefix, hashmap, google, amazon, fb, apple AGAIN*************** (7)(MUST)
0992 Subarrays with K Different Integers Python , Java O(n) O(k) Hard hash table, trick, hashmap, slide window, amazon, google, apple, uber AGAIN**** (1)
1010 Pairs of Songs With Total Durations Divisible by 60 Python , Java O(n) O(1) Medium hash table, good basicm dict, array, amazon, google AGAIN********* (4) (MUST)
1099 Two Sum Less Than K Python , Java O(nlogn) O(1) Medium hash table, dict, sort, amazon, array, two pointers, binary search, fb AGAIN* (1) (not start)
1121 Divide Array Into Increasing Sequences Java O(n) O(1) Hard hash table, dict, google, array, counting Again (not start)
1131 Rank Transform of an Array Python , Java O(nlogn) O(n) Easy hash table, dict, array, amazon, math, google, microsoft OK* (1)
1170 Compare Strings by Frequency of the Smallest Character Java O((m + n) * l + nlogn) O(n) Medium hash table, hashmap, binary search, google, amazon AGAIN*** (1)
1257 Smallest Common Region Java O(n) O(n) Medium hash table, hashmap, good trick, lowest common ancestor (LCA), amazon AGAIN (not start)
1296 Divide Array in Sets of K Consecutive Numbers Python , Java O(nlogn) O(n) Medium hash table, LC 846, dict, google AGAIN (not start)
1726 Tuple with Same Product Python , Java O(n^2) O(n^2) Medium hash table, hashmap, sort, 2 pointers, brute force, good basic, google AGAIN**** (1)(MUST)
1794 Count Pairs of Equal Substrings With Minimum Difference Java O(m + n) O(1) Medium hash table, first, last idx, hashmap, trick, google AGAIN**** (1)(not start)
1923 Longest Common Subpath Python, Java O(m * nlogn) O(n) Hard hash table, hash, bit, amazon, array, binary search, rolling hash AGAIN (not start)
2506 Count Pairs Of Similar Strings Java O(n * l) O(n) Easy hash table, hashmap, LC weekly AGAIN (1)
2592 Maximize Greatness of an Array Java O(nlogn) O(1) Medium hash table, Treemap, 2 pointers, LC weekly, array, greedy AGAIN (1)
2615 Sum of Distances Python , Java O(n) O(n) Medium hash table, good basic, left-right dist, prefix sum, hashmap, LC weekly AGAIN************** (5)(MUST)
2766 Relocate Marbles Java O(n + m) O(n) Medium hash table, hashset, hashmap LC weekly, good trick AGAIN******(1)
2768 Number of Black Blocks Java O(n) O(n) Medium hash table, hashmap, LC weekly AGAIN(1) (not srart)
2870 Minimum Number of Operations to Make Array Empty Java O(n) O(n) Medium hash table, LC 2244, hashmap, count, LC weekly AGAIN (1)
2963 Count the Number of Good Partitions Java O(n) O(n) Hard hash table, LC weekly AGAIN (1) (not start)
3026 Maximum Good Subarray Sum Python O(n) O(n) Medium array, PREFIX SUMS + “CHEAPEST START PER VALUE”, new, google, hashmap, prefix sum AGAIN (MUST) (!!!)
3121 Count the Number of Special Characters II Java O(n) O(1) Medium hash table, greedy, hashmap AGAIN(1) (not srart)
4007 Minimum Initial Strength to Defeat All Monsters Python, Java O(n + m + nlog(sum)) O(n) Medium hash table, good trick, hashmap pair, LC weekly AGAIN(1) (not srart)
4038 Count Integers Appearing in a Single Block Python O(n) O(n) Easy hash table, hashmap, span == cnt trick, first/last idx, LC weekly AGAIN(1)
4066 Maximum Equal Adjacent Pairs After at Most One Replacement Python O(n) O(n) Medium hash table, hashmap, count adjacent (min, max) pairs, gain of x -> y = adjacent {x, y} pairs, nothing lost, LC weekly AGAIN(1)

Linked list

# Title Solution Time Space Difficulty Note Status
0002 Add Two Numbers Python, Java O(n) O(1) Medium linked list, check # 445 Add Two Numbers II, basic, airbnb, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg, neetcode150, top100liked OK**** (6) (but again)
0021 Merge Two Sorted Lists Python, Java O(n) O(1) Easy linked list, uber, amazon, apple, fb, google, microsoft, linkedin, bloomberg, blind75, top100liked OK******** (6) (but again)
0023 Merge k sorted lists Python, Java O(nlogk) O(k) Hard linked list, check #21 Merge Two Sorted Lists, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked OK**** (2) (but again !!!)
0024 Swap Nodes in Pairs Python, Java O(n) O(1) Medium linked list, GOOD basic, LC 100 like, uber, amazon, fb, google, apple, microsoft, bloomberg, top100liked AGAIN****************** (9) (MUST)
0025 Reverse Nodes in k-Group Python, Java O(n) O(1) Hard linked list, good trick, reverse linkedlist, reverse K linkedlist, amazon, google, fb, microsoft, apple, uber, neetcode150, top100liked AGAIN********** (4)
0061 Rotate List Python, Java O(n) O(1) Medium linked list, basic, amazon, apple, microsoft, linkedin AGAIN (2)
0082 Remove Duplicates from Sorted List II Python, Java O(n) O(1) Medium linked list, good basic, check # 083 Remove Duplicates from Sorted List, google, amazon, fb, apple, microsoft, bloomberg AGAIN***** (3)
0083 Remove Duplicates from Sorted List Python, Java O(n) O(1) Easy linked list, basic, google, amazon, fb, apple, microsoft OK*
0092 Reverse Linked List II Python, Java O(n) O(1) Medium linked list, LC 206, reverse k nodes, good trick, fb, apple, google, amazon, microsoft, bloomberg, neetcode250 AGAIN*************** (10) (MUST)
0138 Copy List with Random Pointer Python, Java O(n) O(n) Medium linked list, trick, recursive, hash table, uber, microsoft, amazon, fb, google, apple, bloomberg, neetcode150, top100liked AGAIN******* (7)
0160 Intersection of Two Linked Lists Python, Java O(m + n) O(1) Easy linked list, basic, hash table, 2 pointers, airbnb, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg, top100liked OK******* (7) (again!)
0203 Remove Linked List Elements Python , Java O(n) O(1) Easy linked list, linked list basic, amazon, google, fb, apple, microsoft, bloomberg AGAIN**** (3)
0206 Reverse Linked List Python, Java O(n) O(1) Easy linked list, good basic, amazon, fb, google, apple, microsoft, uber, bloomberg, blind75, top100liked OK*********** (9) (MUST again)
0234 Palindrome Linked List Python, Java O(n) O(1) Easy linked list, amazon, fb, google, apple, microsoft, uber, top100liked OK (4)
0237 Delete Node in a Linked List Python, Java O(1) O(1) Easy linked list, LintCode, apple, google, amazon, fb, microsoft OK * (1) (but again)
0328 Odd Even Linked List Python, Java O(n) O(1) Medium linked list, basic, google, amazon, fb, apple, microsoft, bloomberg OK** (2)
0369 Plus One Linked List Python, Java O(n) O(1) Medium linked list, 🔒, basic, google, amazon AGAIN****** (3)
0430 Flatten a Multilevel Doubly Linked List Python, Java O(n) O(n) Medium linked list, good trick, doubly linked list, dfs, iterative, stack, fb, google, amazon, microsoft, uber, bloomberg AGAIN******** (6)
0445 Add Two Numbers II Python, Java O(m + n) O(m + n) Medium linked list, trick, string, good basic, amazon, google, fb, apple, microsoft, uber, bloomberg AGAIN*** (3)
0707 Design Linked List Python, Java get/addAtIndex/deleteAtIndex: O(n), addAtHead/addAtTail: O(1) O(n) Medium linked list, linked list basic OP, google, amazon, apple, microsoft AGAIN (1)
0708 Insert into a Cyclic Sorted List Python, Java O(n) O(1) Medium linked list, AGAIN, cyclic linked list, good trick, google, amazon, fb, microsoft AGAIN******** (4)
0725 Split Linked List in Parts Python, Java O(n + k) O(1) Medium linked list, mod, split linked list, good trick, amazon, google, apple AGAIN************ (6) (again)
0817 Linked List Components Python, Java O(m + n) O(m) Medium linked list, set, array, google AGAIN** (1)
1836 Remove Duplicates From an Unsorted Linked List Java O(n) O(n) Medium linked list, hashset of seen values, dummy head, good basic, microsoft AGAIN (not start)
2074 Reverse Nodes in Even Length Groups Python, Java O(n) O(1) Medium linked list, reverse in place, parity of the ACTUAL group length, dummy head, sibling of LC 25 AGAIN(1)

Stack

# Title Solution Time Space Difficulty Note Status
0020 Valid Parentheses Python, Java O(n) O(n) Easy stack, good basic, fb, amazon, google, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked OK** (6)
0032 Longest Valid Parentheses Python, Java O(n) O(n) Hard stack, card, 2 scan, 1D DP, brute force, dp, stack, good trick, amazon, fb, microsoft, google, apple, uber, top100liked AGAIN****************** (6)
0071 Simplify Path Python, Java O(n) O(n) Medium stack, basic, amazon, fb, google, apple, microsoft, uber, neetcode250 AGAIN******** (5)
0085 Maximal Rectangle Python, Java O(m * n) O(n) Hard stack, top-100-like, brute force, dp, LC 84, google, amazon, apple, fb, microsoft, uber AGAIN (not start)
0101 Symmetric Tree Python, Java O(n) O(h) Easy stack, good basic, bfs, dfs, linkedin, microsoft, amazon, fb, google, tree, apple, uber, bloomberg, top100liked AGAIN************* (7)
0150 Evaluate Reverse Polish Notation Python, Java O(n) O(n) Medium stack, good trick, amazon, google, fb, apple, microsoft, uber, linkedin, neetcode150 AGAIN********* (5)
0155 Min Stack Python, Java O(1) per op O(n) Medium stack, basic, data structure, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, neetcode150, top100liked OK*********** (7) (but again)
0173 Binary Search Tree Iterator Python, Java ctor: O(h), next: O(1) amortized, hasNext: O(1) O(h) Medium stack, good basic, tree, microsoft, linkedin, google, amazon, fb, apple, uber, bloomberg OK***** (5)
0224 Basic Calculator Python, Java O(n) O(n) Hard stack, basic, trick, LC 227, 772, amazon, google, fb, apple, microsoft, uber AGAIN******* (3)
0227 Basic Calculator II Python, Java O(n) O(n) Medium stack, card, delay op, LC 224, 772, good trick, airbnb, fb, amazon, google, apple, microsoft, uber AGAIN************** (8) (MUST)
0232 Implement Queue using Stacks Python, Java O(1), amortized O(n) Easy stack, stack-queue, EPI, LintCode, amazon, google, fb, apple, microsoft, uber, bloomberg, neetcode250 AGAIN*** (3)(MUST)
0255 Verify Preorder Sequence in Binary Search Tree Python, Java O(n) O(n) Medium stack, 🔒, uber AGAIN (not start)
0321 Create Maximum Number Java O(k^2 * (m + n)) O(m + n) Hard stack, dp, greedy, mono-stack, google, amazon, apple AGAIN (not start) (2)
0331 Verify Preorder Serialization of a Binary Tree Python, Java O(n) O(1) Medium stack, slot counting (no stack needed), preorder serialization, good trick, google AGAIN (not start)
0341 Flatten Nested List Iterator Python, Java O(n) O(n) Medium stack, LC 284, 🔒 Iterator, generator, good basic, amazon, fb***, google, fb, apple, microsoft, uber, linkedin AGAIN********* (6)
0385 Mini Parser Python, Java O(n) O(n) Medium stack, parse nested list, recursion, good basic, google AGAIN
0394 Decode String Python, Java O(n) O(n) Medium stack, card, good basic!!!, pre num string, LC 224, 227, amazon, google, fb, apple, microsoft, uber, bloomberg, neetcode250, top100liked AGAIN******************* (11) (MUST)
0439 Ternary Expression Parser Python, Java O(n) O(n) Medium stack, 🔒 AGAIN (not start)
0456 132 Pattern Python, Java O(n) O(n) Medium stack, binary search, google, amazon, microsoft AGAIN (not start)
0496 Next Greater Element I Python, Java O(n) O(n) Easy stack, good basic, mono stack, LC 739, LC 503, LC 406, google, amazon, fb, apple, microsoft, bloomberg OK*************** (6) (but again)
0503 Next Greater Element II Python, Java O(n) O(n) Medium stack, good basic, LC 739, LC 503, LC 406, next_big_val_idx, google, amazon, fb, apple, microsoft, bloomberg AGAIN************* (7)
0591 Tag Validator Java O(n) O(n) Hard stack, parse tags + CDATA, complex, string, google, amazon, microsoft, uber AGAIN (not start)
0636 Exclusive Time of Functions Python, Java O(n) O(n) Medium stack, trick, good trick, uber, fb, google, amazon, apple, microsoft, linkedin AGAIN************ (6) (MUST)
0682 Baseball Game Python, Java O(n) O(n) Easy stack, good basic, amazon, google, neetcode250 OK* (3)
0735 Asteroid Collision Python, Java O(n) O(n) Medium stack, good basic, microsoft, goldman sachs, fb, amazon, google, uber, neetcode250 AGAIN************** (5)
0739 Daily Temperatures Python, Java O(n) O(n) Medium stack, card, LC 739, LC 503, LC 406, LC 496, LC 42, Monotonic stack, good trick, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, neetcode150, top100liked AGAIN******************* (12) (MUST)
0772 Basic Calculator III Python, Java O(n) O(n) Hard stack, universal calculator (deque + recursion + delay-insert on pre_op), check LC 224, 227, google, amazon, fb, apple, microsoft, uber AGAIN (1)
0853 Car Fleet Python, Java O(nlogn) O(n) Medium stack, good basic, google, amazon, neetcode150 AGAIN********* (5)
0856 Score of Parentheses Python, Java O(n) O(n) Medium stack, stack of scores, or count depth on each (), good trick, google, amazon, fb AGAIN (not start)
0872 Leaf-Similar Trees Python, Java O(n) O(h) Easy stack, top down, bottom up dfs, good basic, tree, binary tree, google, amazon, fb AGAIN***** (MUST)
0895 Maximum Frequency Stack Python, Java push: O(1), pop: O(1) O(n) Hard stack, good basic, heap, design, amazon, apple, linkedin, microsoft, twitter, google, fb, uber, neetcode250 AGAIN********** (1) (not start)
0901 Online Stock Span Python, Java O(n) O(n) Medium stack, mono stack, good basic, google, amazon, fb, microsoft, neetcode250 AGAIN***** (2)
0946 Validate Stack Sequences Python, Java O(n) O(n) Medium stack, simulate push/pop with one stack, good basic, google, amazon, fb, microsoft, linkedin AGAIN
1028 Recover a Tree From Preorder Traversal Java O(n) O(n) Hard stack, brute force, google, string, tree, dfs, amazon, linkedin AGAIN (not start)
1047 Remove All Adjacent Duplicates in String Python, Java O(n) O(n) Easy stack, good basic, LC 1209, fb, amazon, google, apple, microsoft, uber, bloomberg AGAIN************ (3) (MUST)
1081 Smallest Subsequence of Distinct Characters Java O(n) O(n) Medium stack, LC 316, google, amazon AGAIN (1)
1209 Remove All Adjacent Duplicates in String II Python, Java O(n) O(n) Medium stack, LC 1047, good basic, two pointers, greedy, fb, amamzon, apple, spotify, google, amazon, microsoft, bloomberg AGAIN***************** (4) (MUST)
1544 Make The String Great Java O(n) O(n) Easy stack, LC 1047, remove adjacent opposite-case pairs, basic, google AGAIN(1)
1703 Minimum Adjacent Swaps for K Consecutive Ones Python, Java O(n) O(n) Hard stack, heap, sliding window, amazon, array, greedy, google, microsoft AGAIN (not start)
1896 Minimum Cost to Change the Final Value of Expression Python, Java O(n) O(n) Hard stack, complex, dp, dp+stack, dfs, amazon, google AGAIN (not start)
2104 Sum of Subarray Ranges Python, Java O(n) O(n) Medium stack, LC 907, good basic, monotonic stack, brute force, dp, amazon AGAIN************ (5)
2289 Steps to Make Array Non-decreasing Python, Java O(n) O(n) Medium stack, card, mono stack, mono stack + dp, good trick AGAIN************ (2) (MUST)
4045 Count Robot Groups Python O(n) O(1) Medium stack, car fleet (LC 853), right -> left scan, merge keeps the rightmost robot’s state, t=0 touch chains via the neighbour, LC weekly AGAIN(1)
4054 Count Shadow Pairs I Python O(n) O(n) Medium stack, MONOTONIC STACK (NEXT STRICTLY SMALLER) — pairs(i) = window size − equal-value chain, pop on >= not >, O(n^2) early-break draft kept as V0-1, good trick, Frequency Grouping, LC weekly AGAIN************ (1) (MUST)

Tree

# Title Solution Time Space Difficulty Note Status
0094 Binary Tree Inorder Traversal Python, Java O(n) O(h) Medium tree, iteration, recursion, good basic, Morris Traversal, microsoft, fb, google, amazon, bloomberg, neetcode250, top100liked AGAIN********* (4) (MUST)
0124 Binary Tree Maximum Path Sum Python, Java O(n) O(h) Hard tree, google, amazon, fb, microsoft, twitter, apple, uber, bloomberg, blind75, top100liked AGAIN*********** (6) (MUST)
0144 Binary Tree Preorder Traversal Python, Java O(n) O(h) Medium tree, Morris Traversal, google, amazon, apple, uber, neetcode250 OK
0145 Binary Tree Postorder Traversal Java O(n) O(h) Medium tree, Morris Traversal, google, amazon, fb, apple, neetcode250 OK
0208 Implement Trie (Prefix Tree) Python, Java insert/search/startsWith: O(l) O(t) Medium tree, dict tree, LC 211, trie, amazon, fb, google, apple, microsoft, uber, bloomberg, blind75, top100liked AGAIN************** (7) (MUST)
0211 Design Add and Search Words Data Structure Python, Java add: O(l), search: O(n * l) worst O(t) Medium tree, Trie, recursive, node, hashMap, do # 208 first, amazon, fb, google, apple, microsoft, uber, blind75 AGAIN*********** (9) (MUST)
0226 Invert Binary Tree Python, Java O(n) O(h) Easy tree, good basic, google, amazon, fb, apple, microsoft, uber, bloomberg, blind75, top100liked OK******* (4) (but again)
0250 Count Univalue Subtrees Python, Java O(n) O(h) Medium tree, LC 572, google, amazon, fb, bloomberg not start
0297 Serialize and Deserialize Binary Tree Python, Java O(n) O(n) Hard tree, LC 449, BFS, DFS, Binary Tree, google, amazon, fb, apple, microsoft, uber, linkedin, bloomberg, blind75 again******* (4)
0307 Range Sum Query - Mutable Python, Java ctor: O(n), update: O(logn), query: O(logn) O(n) Medium tree, LintCode, DFS, Segment Tree, BIT, check #303 Range Sum Query - Immutable, google, array, divide and conquer, design, amazon, fb AGAIN* (2)(not start)
0427 Construct Quad Tree Java O(n^2 * logn) O(logn) Medium tree, Quadtrees, google, amazon, apple, microsoft, uber, neetcode250 again (not start)
0508 Most Frequent Subtree Sum Python, Java O(n) O(n) Medium tree, dfs, bfs, good basic, amazon, google, apple OK*********** (4) (but again MUST)
0536 Construct Binary Tree from String Python, Java O(n) O(h) Medium tree, 🔒, recursive, str->tree, check LC 606, amazon, google, fb AGAIN******** (6)
0538 Convert BST to Greater Tree Python, Java O(n) O(h) Medium tree, good basic, dfs, BST, cum sum, amazon, fb, microsoft OK************** (6)(MUST)
0543 Diameter of Binary Tree Python, Java O(n) O(h) Easy tree, dfs, trick, google, amazon, fb, apple, microsoft, bloomberg, neetcode150, top100liked AGAIN*********** (7)(MUST)
0545 Boundary of Binary Tree Python, Java O(n) O(h) Medium tree, recursive, dfs, tree boundary, 🔒, good trick, amazon, google, fb, apple, microsoft, uber AGAIN********* (6)
0548 Split Array with Equal Sum Python, Java O(n^2) O(n) Medium tree, 🔒, good trick, array, hash table, prefix sum, fb AGAIN*** (2)
0563 Binary Tree Tilt Python, Java O(n) O(h) Easy tree, post-order dfs, subtree sum, good basic AGAIN
0572 Subtree of Another Tree Python, Java O(m * n) O(h) Easy tree, LC 100, recursive call recursion func, good basic, dfs, bfs, amazon, fb, google, microsoft, bloomberg, blind75 OK************* (10) (but again)
0606 Construct String from Binary Tree Python, Java O(n) O(h) Easy tree, good basic, tree->str, dfs, LC 536, amazon, fb OK************ (8) (again!)
0617 Merge Two Binary Trees Python, Java O(n) O(h) Easy tree, dfs, bfs, good basic, amazon, google, fb, apple, microsoft, uber OK************* (7) (but again)
0623 Add One Row to Tree Python, Java O(n) O(h) Medium tree, good basic, dfs, bfs, re-connect tree, microsoft AGAIN***************** (5)(MUST)
0637 Average of Levels in Binary Tree Python, Java O(n) O(h) Easy tree, bfs, dfs, good basic, fb, google, amazon, microsoft OK*** (4)
0652 Find Duplicate Subtrees Python, Java O(n) O(n) Medium tree, card, good basic, serialization, path, bfs, dfs, Hashmap, amazon, google, fb, microsoft, bloomberg AGAIN************** (9)(MUST)
0653 Two Sum IV - Input is a BST Python, Java O(n) O(h) Easy tree, Two Pointers, 2 sum, bfs, dfs, amazon, fb, google, microsoft, uber OK******* (4)
0654 Maximum Binary Tree Python, Java O(n) ~ O(n^2) O(n) Medium tree, LintCode, Descending Stack, good basic, google, amazon, fb, apple, microsoft AGAIN* (2)
0655 Print Binary Tree Python, Java O(n) O(n) Medium tree, matrix, dfs, bfs, good basic, google, amazon, fb, uber, linkedin AGAIN****** (3)
0662 Maximum Width of Binary Tree Python, Java O(n) O(n) Medium tree, tree width, bfs, dfs, trick, amazon, google, fb, apple, microsoft, bloomberg AGAIN************* (5)(MUST)
0663 Equal Tree Partition Python, Java O(n) O(n) Medium tree, # LC 508, AGAIN, 🔒, Hash, dfs, trick, good trick, amazon, fb OK******** (8)
0677 Map Sum Pairs Python, Java insert: O(l), sum: O(p + t) O(t) Medium tree, Trie, trick, hard, google AGAIN* (2) (not start)
0683 K Empty Slots Python, Java O(n) O(n) Hard tree, BST, bucket, google, array, binary indexed tree, segment tree, amazon not start
0684 Redundant Connection Python, Java O(n) O(n) Medium tree, dfs, graph, Union Find, basic, bfs, google, amazon, neetcode150 AGAIN****** (3) (not start)
0687 Longest Univalue Path Python, Java O(n) O(h) Medium tree, dfs, good basic, path, google, amazon AGAIN********* (5)
0701 Insert into a Binary Search Tree Python, Java, Java-followup O(h) O(h) Medium tree, good basic, BST, BFS, DFS, google, amazon, fb, microsoft, linkedin, neetcode250 OK***** (3)
0814 Binary Tree Pruning Python, Java O(n) O(h) Medium tree, prune, good basic, DFS, basic, LC 1325, google, amazon, fb, apple AGAIN*********** (3)(MUST)
0834 Sum of Distances in Tree Java O(n) O(n) Hard tree, DP, re-rooting pattern, google, amazon, apple AGAIN****** (1) (not start)
0863 All Nodes Distance K in Binary Tree Python, Java O(n) O(n) Medium tree, LC 752, tree -> graph, radiate outward, DFS + BFS, good basic, amazon, google, fb, apple, microsoft, uber AGAIN**************** (5)(MUST)
0865 Smallest Subtree with all the Deepest Nodes Python, Java O(n) O(h) Medium tree, LC 1123, LCA, dfs, basic, amazon, fb AGAIN***************** (6)(MUST)
0889 Construct Binary Tree from Preorder and Postorder Traversal Python, Java O(n) O(h) Medium tree, DFS, stack, trick, recursive, google, amazon, fb, uber AGAIN** (2) (not start*)
0897 Increasing Order Search Tree Python, Java O(n) O(h) Easy tree, DFS, good basic, inorder, google, amazon, fb, apple AGAIN** (2)
0919 Complete Binary Tree Inserter Python, Java ctor: O(n)
insert: O(1)
get_root: O(1)		 O(n) Medium tree, bst, google, amazon, fb, microsoft AGAIN** (2)
0938 Range Sum of BST Python, Java O(n) O(h) Easy tree, DFS, check # 108 Convert Sorted Array to Binary Search Tree, google, amazon, fb, apple, microsoft OK* (2)
0951 Flip Equivalent Binary Trees Python, Java O(n) O(h) Medium tree, recursion, DFS, google, amazon, fb AGAIN*** (3)
0958 Check Completeness of a Binary Tree Python, Java O(n) O(w) Medium tree, BFS, DFS, basic, google, amazon, fb, microsoft AGAIN** (2)
0965 Univalued Binary Tree Python, Java O(n) O(h) Easy tree, DFS, BFS, good basic, google AGAIN** (2)
0971 Flip Binary Tree To Match Preorder Traversal Python, Java O(n) O(h) Medium tree, DFS, trick AGAIN** (2) (not start)
0979 Distribute Coins in Binary Tree Python, Java O(n) O(h) Medium tree, DFS, trick, google, amazon, fb, microsoft AGAIN************ (3) (MUSTS)
1032 Stream of Characters Java ctor: O(t), query: O(l) O(t) Hard tree, trie, node, google, amazon, fb, microsoft AGAIN****** (1)
1157 Online Majority Element In Subarray Java ctor: O(n), query: O(klogn) O(n) Hard tree, google, array, binary search, design AGAIN (not start)
1325 Delete Leaves With a Given Value Java, Python O(n) O(h) Medium tree, dfs, post-order, LC 450, 814, google, amazon, neetcode250 AGAIN********** (4)(MUST)
1339 Maximum Product of Splitted Binary Tree Python, Java O(n) O(h) Medium tree, dfs, amazon AGAIN*** (1) (not start)
1372 Longest ZigZag Path in a Binary Tree Python, Java O(n) O(h) Medium tree, dfs, bfs, post order, good trick, amazon AGAIN*** (1) (not start)
1448 Count Good Nodes in Binary Tree Python, Java O(n) O(h) Medium tree, max in path, dfs, bfs, good trick, needcode, google, amazon, microsoft, neetcode150 AGAIN************* (3) (MUST)
1522 Diameter of N-Ary Tree Java O(n) O(h) Medium tree, LC 543, fb, microsoft AGAIN (not start)
1666 Change the Root of a Binary Tree Java O(h) O(h) Medium tree, LC 1448, good trick, google AGAIN (1) (not start)
1740 Find Distance in a Binary Tree Python, Java O(n) O(h) Medium tree, LCA, node dist, DFS, good basic, google, amazon, apple AGAIN*************** (5)(MUST)
2331 Evaluate Boolean Binary Tree Java O(n) O(h) Easy tree, DFS, good basic OK**** (1)
2415 Reverse Odd Levels of Binary Tree Java O(n) O(n) Medium tree, LC 226, dfs, bfs AGAIN (not start)
2509 Cycle Length Queries in a Tree Java O(q * logn) O(1) Hard tree, LC weekly AGAIN (not start)
2641 Cousins in Binary Tree II Java O(n) O(n) Medium tree, LC weekly, LC 993 AGAIN (1)
2707 Extra Characters in a String Java O(n^2) O(n + t) Medium tree, dp, Trie, neetcode250 AGAIN (not start)
3093 Longest Common Suffix Queries Java O(t + q * l) O(t) Hard tree, Trie AGAIN (not start)

Heap

# Title Solution Time Space Difficulty Note Status
0264 Ugly Number II Python, Java O(n) O(n) Medium heap, good trick, LC 263, LC 313, LintCode, DP, microsoft, google, amazon, apple AGAIN*********** (4) (MUST)
0295 Find Median from Data Stream Python, Java addNum: O(logn), findMedian: O(1) O(n) Hard heap, priority queue, trick, stream, amazon, google, fb, apple, microsoft, uber, bloomberg, blind75, top100liked, netflix AGAIN****** (6)
0313 Super Ugly Number Python, Java O(n * k) O(n + k) Medium heap, BST, array, math, dp, google, amazon, fb, apple AGAIN (not start*)
0373 Find K Pairs with Smallest Sums Python, Java O(k * log(min(n, m, k))) O(min(n, m, k)) Medium heap, google, good basic, amazon, fb, apple, microsoft, uber, linkedin AGAIN******* (1)
0378 Kth Smallest Element in a Sorted Matrix Python, Java O(klogn) O(k) Medium heap, binary search, matrix, LintCode, google, amazon, fb, apple, microsoft, uber AGAIN** (1)
0502 IPO Java O(nlogn) O(n) Hard heap, PQ, amazon, uber, neetcode250 AGAIN (not start)
0506 Relative Ranks Java O(nlogn) O(n) Easy heap, PQ, sort, hashmap, google AGAIN (not start)
0703 Kth Largest Element in a Stream Python, Java ctor: O(nlogk), add: O(logk) O(k) Easy heap, priority queue, amazon, google, fb, apple, microsoft, neetcode150 AGAIN******** (5)
0846 Hand of Straights Python, Java O(nlogn) O(n) Medium heap, LC 1296, good basic, PQ, Treemap, hashmap, google, array, greedy, apple, neetcode150 OK******** (3)
0855 Exam Room Python, Java seat: O(logn)
leave: O(logn)		 O(n) Medium heap, treeSet, BST, Hash, trick, LC 849, google, fb, uber AGAIN* (3) (not start)
1046 Last Stone Weight Python, Java O(nlogn) O(n) Easy heap, Priority Queue, google, amazon, neetcode150 OK
1054 Distant Barcodes Java O(nlogn) O(n) Medium heap, PQ, LC 767, amazon Again (1)
1130 Minimum Cost Tree From Leaf Values Python, Java O(n) O(n) Medium heap, LC 1167, monotonic stack (O(n)) or interval dp (O(n^3)), greedy, array, amazon not start
1167 Minimum Cost to Connect Sticks Python, Java O(nlogn) O(n) Medium heap, LC 1130, good basic, amazon, google AGAIN***** (3)
1353 Maximum Number of Events That Can Be Attended Python, Java O(nlogn) O(n) Medium heap, LC 252, 253, good trick, meeting room, PRIORITY QUEUE, fb, twitter, amazon, google, apple, microsoft AGAIN********* (4) (MUST)
1383 Maximum Performance of a Team Java O(nlogn) O(n) Hard heap, PQ, amazon AGAIN***** (1)
1405 Longest Happy String Python, Java O(n) O(1) Medium heap, PQ, most_freq, LC 767, amazon, microsoft, neetcode250 AGAIN************* (2) (MUST)
1438 Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit Python, Java O(n) O(n) Medium heap, PQ, treemap, dequeue, good trick, google, amazon, uber AGAIN***** (MUST)
1481 Least Number of Unique Integers after K Removals Python, Java O(nlogn) O(n) Medium heap, good trick, greedy, Counter, dict, amazon, array, fb AGAIN******** (3)
1642 Furthest Building You Can Reach Python O(nlogn) O(n) Medium heap, min-heap keeps the ladders biggest climbs, pay bricks for the smallest, greedy, good trick, google, amazon, microsoft AGAIN(1)
1647 Minimum Deletions to Make Character Frequencies Unique Java O(nlogn) O(n) Medium heap, greedy, PQ, good trick, hash table, string, amazon, apple, microsoft AGAIN***********(2)
1675 Minimize Deviation in Array Java O(nlogn * logM) O(n) Hard heap, PQ, amazon AGAIN (not start)
1834 Single-Threaded CPU Java O(nlogn) O(n) Medium heap, good trick, pq, google, fb, neetcode250 AGAIN***** (1)
1882 Process Tasks Using Servers Python O((n + m) * logn) O(n) Medium heap, two heaps (free by weight / busy by free-time), wait branch clocks from free_at not j, LC 1834, google, amazon AGAIN(1)
2406 Divide Intervals Into Minimum Number of Groups Python, Java O(nlogn) O(n) Medium heap, LC 253, PQ, sort, scan line, good basic AGAIN********** (2) (MUST)
2542 Maximum Subsequence Score Java O(nlogn) O(n) Medium heap, pq with pair, good trick, sort AGAIN (1)
2593 Find Score of an Array After Marking All Elements Java O(nlogn) O(n) Medium heap, good trick, pq, sort, slide window, LC weekly AGAIN***** (1)
3092 Most Frequent IDs Python, Java O(nlogn) O(n) Medium heap, PQ, lazy delete, hashmap, LC weekly AGAIN********** (MUST) (1)

Bit Manipulation

# Title Solution Time Space Difficulty Note Status
0136 Single Number Python, Java O(n) O(1) Easy bit manipulation, airbnb, amazon, fb, google, apple, microsoft, uber, bloomberg, neetcode150, top100liked OK
0137 Single Number II Python, Java O(n) O(1) Medium bit manipulation, LC 136, count bits mod 3 / ones-twos state machine, good trick, google, amazon, fb, apple, microsoft OK
0190 Reverse Bits Python, Java O(1) O(1) Easy bit manipulation, bit, apple, google, amazon, fb, microsoft, blind75 AGAIN*** (2)
0191 Number of 1 Bits Python, Java O(1) O(1) Easy bit manipulation, apple, google, amazon, fb, microsoft, blind75 OK*
0201 Bitwise AND of Numbers Range Python, Java O(1) O(1) Medium bit manipulation, common binary prefix, shift right until m == n, trick, amazon, fb, neetcode250 AGAIN (not start)
0231 Power of Two Python, Java O(1) O(1) Easy bit manipulation, good basic, amazon, google, apple, microsoft OK*** (3)
0260 Single Number III Python, Java O(n) O(1) Medium bit manipulation, xor, ^=, ^, google, amazon, fb, apple AGAIN*
0268 Missing Number Python, Java O(n) O(1) Easy bit manipulation, xor, amazon, fb, google, apple, microsoft, bloomberg, blind75 OK* (2)
0318 Maximum Product of Word Lengths Python, Java O(n^2 + n * l) O(n) Medium bit manipulation, Counting Sort, Pruning, google AGAIN (not start)
0342 Power of Four Python, Java O(1) O(1) Easy bit manipulation, power of num OK*
0371 Sum of Two Integers Python, Java O(1) O(1) Medium bit manipulation, good basic, fb, amazon, apple, microsoft, uber, blind75 AGAIN********* (5) (bit op not start)
0389 Find the Difference Python, Java O(n) O(1) Easy bit manipulation, amazon, google, fb OK (2)
0393 UTF-8 Validation Python, Java O(n) O(1) Medium bit manipulation, utf-8 encoding, google, fb, amazon, apple AGAIN**** (not start*) (5)
0401 Binary Watch Python, Java O(1) O(1) Easy bit manipulation, enumerate the 12 * 60 times or use bit count, brute force, basic, google, apple OK*
0421 Maximum XOR of Two Numbers in an Array Python, Java O(n) O(n) Medium bit manipulation, Trie of bits or prefix hashset, greedy from the MSB, good trick, google, amazon, microsoft AGAIN (not start)
0461 Hamming Distance Python, Java O(1) O(1) Easy bit manipulation, fb, google, amazon OK* (2)
0462 Minimum Moves to Equal Array Elements II Python, Java O(n) on average O(1) Medium bit manipulation, median minimizes the sum of absolute diffs, quick select, sort, math, array, microsoft AGAIN*
0477 Total Hamming Distance Python, Java O(n) O(1) Medium bit manipulation, fb, amazon AGAIN****** (not start*) (4)
0645 Set Mismatch Python, Java O(n) O(1) Easy bit manipulation, amazon, fb OK* (3)
0693 Binary Number with Alternating Bits Python, Java O(1) O(1) Easy bit manipulation, trick AGAIN*
0762 Prime Number of Set Bits in Binary Representation Python, Java O(1) O(1) Easy bit manipulation, basic, prime number, amazon OK* (4)
0868 Binary Gap Python, Java O(1) O(1) Easy bit manipulation, trick, linear scan AGAIN*
0898 Bitwise ORs of Subarrays Python, Java O(n * logM) O(logM) Medium bit manipulation, set of distinct ORs per index (at most logM), good trick, amazon AGAIN (not start)
1573 Number of Ways to Split a String Python, Java O(n) O(1) Medium bit manipulation, amazon, binary, math, string AGAIN** (not start)
1915 Number of Wonderful Substrings Python, Java O(n) O(1) Medium bit manipulation, bit mask, bit, prefix sum, dp, amazon, google AGAIN*** (2) (not start)
2683 Neighboring Bitwise XOR Java O(n) O(1) Medium bit manipulation, bit op, simulation LC weekly 345 AGAIN*** (1)
2871 Split Array Into Maximum Number of Subarrays Java O(n) O(1) Medium bit manipulation, bit op, LC weekly AGAIN*** (1)
3688 Bitwise OR of Even Numbers in an Array Java O(n) O(1) Easy bit manipulation, bit mask OK

String

# Title Solution Time Space Difficulty Note Status
0005 Longest Palindromic Substring Python, Java O(n^2) O(1) Medium string, card, LC 647, good trick, 2 pointer, recursive, Manacher's Algorithm, LC 100 like, DP, uber, amazon, fb, google, apple, microsoft, bloomberg, blind75, top100liked AGAIN******************* (8)(MUST)
0006 ZigZag Conversion Python, Java O(n) O(n) Medium string, simulate the rows, basic, trick, google, amazon, fb, apple, microsoft, uber AGAIN (not start)
0008 String to Integer (atoi) Python, Java O(n) O(1) Medium string, string op, regular expression, uber, amazon, fb, google, apple, microsoft, linkedin, bloomberg AGAIN***** (5)
0014 Longest Common Prefix Python, Java O(n * k) O(1) Easy string, good basic, LCP, prefix, binary search, scan, google, amazon, fb, apple, microsoft, uber, bloomberg, neetcode250 AGAIN (5) (!!!)
0028 Implement strStr() Python, Java O(n + k) O(k) Easy string, KMP Algorithm, fb, google, amazon, apple, microsoft, uber, bloomberg OK (3)
0028 Find the Index of the First Occurrence in a String Java O(n + k) O(k) Easy string, duplicate of LC 28, KMP Algorithm, Rabin-Karp Algorithm, two pointers, google, amazon, fb, apple, microsoft, uber, bloomberg OK (3)
0038 Count and Say Python, Java O(n * 2^n) O(2^n) Medium string, recursion, iteration, basic, fb, google, amazon, apple, microsoft AGAIN*********** (5)
0043 Multiply Strings Python, Java O(m * n) O(m + n) Medium string, twitter, fb, google, amazon, apple, microsoft, uber, neetcode150 AGAIN*** (3)
0058 Length of Last Word Python, Java O(n) O(1) Easy string, scan from the end, basic, google, amazon, fb, microsoft OK
0067 Add Binary Python, Java O(n) O(1) Easy string, bit op, good basic, fb, amazon, google, apple, microsoft, uber, neetcode250 OK***** (7) (but again)
0076 Minimum Window Substring Python, Java O(m + n) O(k) Hard string, slide window, good pattern, google, amazon, fb, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN*********** (3)
0125 Valid Palindrome Python, Java O(n) O(1) Easy string, LC 680, amazon, fb, google, apple, microsoft, linkedin, bloomberg, blind75 OK
0151 Reverse Words in a String Python, Java O(n) O(1) Medium string, amazon, fb, google, apple, microsoft, uber OK (2)
0161 One Edit Distance Python, Java O(m + n) O(1) Medium string, 🔒, DP, 2 pointers, fb, google, amazon, apple, microsoft, uber AGAIN ************ (6)(MUST)
0165 Compare Version Numbers Python, Java O(n) O(1) Medium string, good basic, amazon, apple, google, microsoft OK** (5)
0186 Reverse Words in a String II Python, Java O(n) O(1) Medium string, LC 151, LC 557, 🔒, microsoft, uber, amazon, fb AGAIN* (3)
0242 Valid Anagram Python, Java O(n) O(1) Easy string, LintCode, amazon, fb, google, apple, microsoft, uber, bloomberg, blind75 OK
0271 Encode and Decode Strings Python, Java O(n) O(1) Medium string, decode-encode, string op, check # 394 Decode String, 🔒, google, fb, apple, microsoft, uber, blind75 AGAIN******* (4)
0306 Addictive Number Python, Java O(n^3) O(n) Medium string, backtracking over the first two numbers, big-int add, dfs, LC 842, google AGAIN (not start*)
0340 Longest Substring with At Most K Distinct Characters Python, Java O(n) O(k) Hard string, sliding window, google, amazon, fb, microsoft, uber, bloomberg not start
0383 Ransom Note Python, Java O(n) O(1) Easy string, EPI, apple, google, amazon, fb, microsoft OK*
0405 Convert a Number to Hexadecimal Python, Java O(n) O(1) Easy string, basics decimal -> Hexadecimal, google, amazon, fb AGAIN
0408 Valid Word Abbreviation Python, Java O(n) O(1) Easy string, 🔒, google, fb AGAIN (not start)
0415 Add Strings Python, Java O(n) O(1) Easy string, good basic, add xxx to sum, airbnb, google, fb, amazon, apple, microsoft, uber, bloomberg OK****** (4)
0434 Number of Segments in a String Python, Java O(n) O(1) Easy string, count word starts, split, basic, apple OK
0443 String Compression Python, Java O(n) O(1) Easy string, shoptify, basics, google, amazon, fb, apple, microsoft, bloomberg AGAIN**
0459 Repeated Substring Pattern Python, Java O(n) O(n) Easy string, good basic, KMP Algorithm, amazon, google, fb, microsoft OK*** (6)
0468 Validate IP Address Python, Java O(1) O(1) Medium string, ip basic, twitter, fb, amazon, google, microsoft AGAIN****** (5)
0482 License Key Formatting Python, Java O(n) O(1) Easy string, basic, google, amazon OK** (4) (again)
0520 Detect Capital Python, Java O(l) O(1) Easy string, three valid cases (all upper / all lower / leading capital), basic, google, amazon OK
0521 Longest Uncommon Subsequence I Python, Java O(min(a, b)) O(1) Easy string, if the two strings differ the answer is max(len), trick, google OK*
0522 Longest Uncommon Subsequence II Python, Java O(l * n^2) O(1) Medium string, sort, compare all pairs, LC 521, google, apple AGAIN (not start)
0524 Longest Word in Dictionary through Deleting Python, Java O(d * l + d * logd) O(1) Medium string, good basic, sort, 2 pointers, subsequence check, google AGAIN*********** (2)
0539 Minimum Time Difference Python, Java O(nlogn) O(n) Medium string, basic, map & zip trick, google, apple AGAIN**
0541 Reverse String II Python, Java O(n) O(1) Easy string, reverse every 2k block, basic, google, amazon, apple, microsoft AGAIN**** (1)
0551 Student Attendance Record I Python, Java O(n) O(1) Easy string, count A and 3 consecutive L, basic, google OK**
0556 Next Greater Element III Python, Java O(n) O(n) Medium string, LC 31 next permutation applied to digits, good trick, amazon, fb, apple, microsoft AGAIN (not start)
0557 Reverse Words in a String III Python, Java O(n) O(1) Easy string, split, reverse each word, basic, google, amazon, apple, microsoft OK
0616 Add Bold Tag in String Python, Java O(n * d * l) O(n) Medium string, LC 758, 🔒, google, fb AGAIN (not start)
0647 Palindromic Substrings Python, Java O(n^2) O(1) Medium string, LC 005, greedy, 2D DP, expand from center, 2 pointers, good basic, Manacher's Algorithm, linkedin, amazon, fb, google, apple, microsoft, uber, blind75 OK************** (10) (MUST)
0648 Replace Words Python, Java O(n) O(t) Medium string, Trie, hashset, good basic, amazon, fb, uber AGAIN******* (2)
0657 Judge Route Circle Python, Java O(n) O(1) Easy string, count moves per direction, LC 1041, basic, google, amazon OK
0678 Valid Parenthesis String Python, Java O(n) O(1) Medium string, greedy, dp, stack, 2 pointers, good trick, google, amazon, fb, apple, microsoft, uber, neetcode150 AGAIN********** (3) (MUST)
0680 Valid Palindrome II Python, Java O(n) O(1) Easy string, LC 125, two pointers, good basic, Palindrome, fb, google, amazon, apple, microsoft, neetcode250 AGAIN************* (4) (MUST)
0681 Next Closest Time Python, Java O(1) O(1) Medium string, subset of set, <=, strptime, google, fb, amazon, uber OK*** (5)
0686 Repeated String Match Python, Java O(n + m) O(1) Medium string, brute force, math, Rabin-Karp Algorithm, google, amazon, fb AGAIN**** (3)
0696 Count Binary Substrings Python, Java O(n) O(1) Easy string, good trick, linear scan, group sub-string, amazon, google AGAIN******* (3) (MUST)
0720 Longest Word in Dictionary Python, Java O(n * l) O(t) Medium string, Trie, DFS, good trick, google, amazon, fb AGAIN**** (1)
0722 Remove Comments Python, Java O(n) O(k) Medium string, google, amazon, fb, apple, microsoft, uber AGAIN (1)
0734 Sentence Similarity Python , Java O(n + p) O(p) Easy string, good basic, graph, hash table, collections.defaultdict(set), google, fb OK***** (5)
0751 IP to CIDR Python, Java O(n) O(1) Medium string, 🔒, bit manipulation, largest CIDR block that fits, ip, google AGAIN (not start*)
0758 Bold Words in String Python, Java O(n * l) O(t) Easy string, 🔒, LC 616, variant of Add Bold Tag in String, google AGAIN (not start)
0791 Custom Sort String Python, Java O(n) O(1) Medium string, good basic, sort, counter, amazon, fb, google, uber AGAIN************ (7) (MUST)
0796 Rotate String Python, Java O(n) O(1) Easy string, good basic, KMP Algorithm, Rabin-Karp Algorithm, amazon, google, apple, microsoft, linkedin OK**** (2)(but again)
0804 Unique Morse Code Words Python, Java O(n) O(n) Easy string, map letters to morse, hashset of transformations, basic, google, apple, microsoft OK*
0806 Number of Lines To Write String Python, Java O(n) O(1) Easy string, greedy line filling, basic, google OK*
0809 Expressive Words Python, Java O(n + s) O(l + s) Medium string, 2 pointers, group len, good basic, google, amazon, fb AGAIN****** (2)
0816 Ambiguous Coordinates Python, Java O(n^4) O(n) Medium string, trick, google AGAIN**** (1)
0819 Most Common Word Python, Java O(m + n) O(m + n) Easy string, regular expression, amazon, google, microsoft OK** (2)
0820 Short Encoding of Words Python, Java O(n) O(t) Medium string, Trie, amazon AGAIN (not start)
0824 Goat Latin Python, Java O(n + w^2) O(l) Easy string, string basic, fb, google OK
0828 Count Unique Characters of All Substrings of a Given String Python, Java O(n) O(1) Hard string, LC 1248, count each char’s contribution (prev/next same char), dp, amazon, google AGAIN*** (2)
0831 Masking Personal Information Python, Java O(1) O(1) Medium string, regular expression OK*
0833 Find And Replace in String Python, Java O(n + m) O(n) Medium string, good basic, string op, hashmap, google, amazon, fb, microsoft, linkedin AGAIN****** (3)
0848 Shifting Letters Python, Java O(n) O(1) Medium string, remainder, basic, amazon, fb AGAIN**
0859 Buddy Strings Python, Java O(n) O(1) Easy string, compare differing positions, duplicate-char check, trick, google, fb AGAIN*
0880 Decoded String at Index Python, Java O(n) O(1) Medium string, trick, amazon AGAIN (not start**)
0884 Uncommon Words from Two Sentences Python, Java O(m + n) O(m + n) Easy string, collections Counter, trick, google, amazon, fb, microsoft OK*
0890 Find and Replace Pattern Python, Java O(n * l) O(1) Medium string, hashmap, pattern, LC 49, google, amazon, apple AGAIN *** (3)
0893 Groups of Special-Equivalent Strings Python, Java O(n * l) O(n) Easy string, sort even- and odd-indexed chars separately, hashset, trick, fb AGAIN*
0916 Word Subsets Python, Java O(m + n) O(1) Medium string, max char count across all words in b, Counter, good trick, google, amazon, fb AGAIN (not start)
0917 Reverse Only Letters Python, Java O(n) O(1) Easy string, good basic, stack, pointer, google, amazon, apple, microsoft AGAIN**** (1)
0925 Long Pressed Name Python, Java O(n) O(1) Easy string, two pointer, basic, trick, google AGAIN*
0929 Unique Email Addresses Python, Java O(n * l) O(n * l) Easy string, normalize local part (drop dots, cut at +), hashset, basic, google, amazon OK
0939 Minimum Area Rectangle Python, Java O(n^2) O(n) Medium string, hashmap, brute force, google, array, math, amazon, fb, apple, microsoft AGAIN (2) (!!!)
0942 DI String Match Python, Java O(n) O(1) Easy string, good basic, 2 pointers, google, amazon, microsoft, uber AGAIN*** (1)
0944 Delete Columns to Make Sorted Python, Java O(n * l) O(1) Easy string, count columns that are not sorted, basic, google AGAIN (not start)
0953 Verifying an Alien Dictionary Python, Java O(n * l) O(1) Easy string, map chars to the alien order then compare adjacent words, good basic, amazon, fb, apple, microsoft, uber, neetcode250 AGAIN********** (3) (MUST)
0955 Delete Columns to Make Sorted II Python, Java O(n * l) O(n) Medium string, LC 944, greedy column keeping, good trick, google AGAIN (not start)
1119 Remove Vowels from a String Python, Java O(n) O(n) Easy string, amazon OK
2048 Next Greater Numerically Balanced Number Python, Java O(A * log A) with A the answer O(1) Medium string, BRUTE-FORCE SCAN UPWARD (the search space is provably tiny) AGAIN(1)
4006 Count Valid Prefixes Python, Java O(n) O(1) Easy string, prefix, good basic, LC weekly OK
4043 Count Rotations With Exactly K Equal Adjacent Pairs Python O(n) O(1) Easy string, cyclic pairs, a rotation only cuts ONE pair so score is C or C-1, brute force O(n^2) as V0, LC weekly AGAIN(1)

Queue

# Title Solution Time Space Difficulty Note Status
0239 Sliding Window Maximum Python, Java O(n) O(k) Hard queue, sliding window, PQ, deque, good trick, amazon, google, fb, apple, microsoft, uber, neetcode150, top100liked AGAIN**************** (8) (MUST)
0281 Zigzag Iterator Python, Java O(n) O(k) Medium queue, good basic, 🔒, google, fb, amazon, apple AGAIN******* (5)
0346 Moving Average from Data Stream Python, Java O(1) O(w) Easy queue, 🔒, google, fb, amazon, apple, microsoft, uber, bloomberg OK** (6)
0622 Design Circular Queue Python, Java O(1) per op O(k) Medium queue, good basic, array, linked list, design, circular queue, amazon, fb, apple, airbnb, microsoft, google, neetcode250 AGAIN************ (3) (MUST)
0933 Number of Recent Calls Python, Java O(1) on average O(w) Easy queue, deque, drop pings older than t - 3000, basic, google AGAIN**

Math

# Title Solution Time Space Difficulty Note Status
0007 Reverse Integer Python, Java O(1) O(1) Medium math, 0x7FFFFFFF, amazon, apple, google, fb, microsoft, uber, bloomberg, neetcode150 OK* (3)
0009 Palindrome Number Python, Java O(1) O(1) Easy math, amazon, google, fb, apple, microsoft, bloomberg OK
0012 Integer to Roman Python, Java O(1) O(1) Medium math, math basic, twitter, fb, amazon, google, apple, microsoft, uber, linkedin, bloomberg AGAIN****** (4)
0013 Roman to Integer Python, Java O(n) O(1) Easy math, good trick, map, uber, amazon, fb, google, apple, microsoft, linkedin, neetcode250 AGAIN***** (6)
0029 Divide Two Integers Python, Java O(logn) O(1) Medium math, binary search, trick, fb, google, amazon, apple, microsoft, uber AGAIN***** (3)
0050 Pow(x, n) Python, Java O(logn) O(logn) Medium math, good trick, amazon, fb, recursion, google, apple, microsoft, uber, linkedin, bloomberg, neetcode150 AGAIN****** (4)
0060 Permutation Sequence Python, Java O(n^2) O(n) Medium math, Cantor Ordering, trick, amazon, google, fb, apple, microsoft AGAIN*** (2)
0089 Gray Code Python, Java O(2^n) O(1) Medium math, bit op, amazon, google, microsoft AGAIN ********** (6)
0149 Max Points on a Line Java O(n^2) O(n) Hard math, hashmap, google, amazon, apple, microsoft, uber, linkedin AGAIN(1)
0166 Fraction to Recurring Decimal Python, Java O(n) O(n) Medium math, hashmap remainder -> index to detect the repeating cycle, good trick, google, amazon, fb, apple, uber AGAIN (not start)
0168 Excel Sheet Column Title Python, Java O(logn) O(1) Easy math, trick, residual, AGAIN, fb, google, amazon, apple, microsoft, uber, neetcode250 AGAIN****** (5)
0171 Excel Sheet Column Number Python, Java O(n) O(1) Easy math, base-26 accumulation, LC 168, basic, google, amazon, fb, apple, microsoft, uber AGAIN (not start)
0172 Factorial Trailing Zeroes Python, Java O(logn) O(1) Easy math, basic, iteration, recursion, amazon, fb, microsoft, bloomberg AGAIN* (2)
0223 Rectangle Area Python, Java O(1) O(1) Easy math, area sum minus the overlap, basic, amazon, fb, apple, microsoft AGAIN
0258 Add Digits Python, Java O(1) O(1) Easy math, digital root: 1 + (n - 1) % 9, trick, google, amazon, apple, microsoft AGAIN
0263 Ugly Number Python, Java O(1) O(1) Easy math, divide out 2, 3, 5, LC 264, basic, amazon, apple OK* (2)
0273 Integer to English Words Python, Java O(logn) O(1) Hard math, amazon, passed, google, fb, apple, microsoft, uber, linkedin, bloomberg not start
0292 Nim Game Python, Java O(1) O(1) Easy math, LintCode, google OK*
0319 Bulb Switcher Python, Java O(1) O(1) Medium math, answer is floor(sqrt(n)) - only perfect squares have an odd divisor count, good trick, fb, apple, microsoft AGAIN
0326 Power of Three Python, Java O(1) O(1) Easy math, loop divide by 3, or 3^19 % n == 0, LC 231, LC 342, basic, google, apple OK
0338 Counting Bits Python, Java O(n) O(n) Medium math, dp, bit manipulation, dp[i] = dp[i >> 1] + (i & 1), good basic, google, amazon, fb, apple, uber, blind75 OK
0343 Integer Break Python, Java O(n^2) O(n) Medium math, max product, split into 3s, trick, DP, google, amazon, fb, apple, neetcode250 AGAIN********** (3)(MUST)
0365 Water and Jug Problem Python, Java O(logn) O(1) Medium math, Bézout's identity, google, microsoft, uber AGAIN (not start)
0372 Super Pow Python, Java O(n) O(1) Medium math, modular fast power over the digit array AGAIN
0382 Linked List Random Node Python, Java ctor: O(1), getRandom: O(n) O(1) Medium math, Reservoir Sampling, google, amazon, fb AGAIN (not start)
0386 Lexicographical Numbers Python, Java O(n) O(1) excluding output Medium math, pre-order DFS over the 10-ary number trie, iterative, good trick, google, amazon, microsoft, bloomberg AGAIN (not start)
0390 Elimination Game Python, Java O(logn) O(1) Medium math, track head / step / remaining count, good trick, amazon, bloomberg AGAIN (not start)
0398 Random Pick Index Python, Java ctor: O(1), pick: O(n) O(1) Medium math, Reservoir Sampling, hashmap of value -> indices, fb, google, amazon, microsoft OK* (4)
0400 Nth Digit Python, Java O(logn) O(1) Easy math, count digits per length band then locate the number, google, amazon, fb AGAIN
0413 Arithmetic Slices Python, Java O(n) O(1) Medium math, dp, count consecutive runs with the same diff, good basic, amazon, array, sliding window, fb OK*** (1) (but again)
0423 Reconstruct Original Digits from English Python, Java O(n) O(1) Medium math, GCJ2016 - Round 1B AGAIN (not start)
0441 Arranging Coins Python, Java O(logn) O(1) Easy math, Binary Search on the row count, or the quadratic formula, amazon, apple OK
0453 Minimum Moves to Equal Array Elements Python, Java O(n) O(1) Easy math, incrementing n-1 elements equals decrementing 1, sum - n * min, trick, amazon, apple AGAIN
0458 Poor Pigs Python, Java O(logn) O(1) Hard math, information theory, (tests + 1) ^ pigs >= buckets, good trick AGAIN
0469 Convex Polygon Python, Java O(n) O(1) Medium math, 🔒, cross-product sign must stay consistent, geometry, google AGAIN (not start)
0470 Implement Rand10() Using Rand7() Python, Java O(1) O(1) Medium math, rejection sampling, LC 478, good trick, google, apple, microsoft, uber AGAIN (not start)
0478 Generate Random Point in a Circle Python, Java O(1) O(1) Medium math, rejection sampling or inverse transform with sqrt, geometry, fb AGAIN (not start)
0497 Random Point in Non-overlapping Rectangles Python, Java ctor: O(n)
pick: O(logn)		 O(n) Medium math, prefix sum of rectangle areas + binary search, good trick, google AGAIN (not start)
0504 Base 7 Python, Java O(logn) O(logn) Easy math, base conversion, good basic, recursion, google AGAIN******** (1)
0517 Super Washing Machines Python, Java O(n) O(1) Hard math, max of (max deficit, max single surplus), greedy, amazon, array, microsoft AGAIN (not start)
0519 Random Flip Matrix Python, Java ctor: O(1)
pick: O(1) reset: O(n)		 O(n) Medium math, hashmap-based virtual Fisher-Yates swap, good trick, google AGAIN (not start)
0528 Random Pick with Weight Python, Java O(logn) O(n) Medium math, good basic, binary search, prefix sum, google, amazon, fb, apple, microsoft, uber, linkedin AGAIN**** (1)
0537 Complex Number Multiplication Python, Java O(1) O(1) Medium math, amazon OK (3)
0553 Optimal Division Python, Java O(n) O(1) Medium math, string, amazon OK* (4)
0573 Squirrel Simulation Python, Java O(n) O(1) Medium math, 🔒 AGAIN (not start)
0592 Fraction Addition and Subtraction Python, Java O(nlogx) O(n) Medium math, parse signed fractions, reduce with gcd / lcm AGAIN
0593 Valid Square Python, Java O(1) O(1) Medium math, google, fb AGAIN
0598 Range Addition II Python, Java O(p) O(1) Easy math, answer is min(all a) * min(all b), trick, amazon AGAIN
0625 Minimum Factorization Python, Java O(loga) O(1) Medium math, 🔒 OK*
0628 Maximum Product of Three Numbers Python, Java O(n) O(1) Easy math, amazon, google, fb, apple, microsoft, uber OK (2)
0633 Sum of Square Numbers Python, Java O(sqrt© * logc) O(1) Easy math, two pointers from 0 to sqrt©, or test each a, basic, apple, linkedin OK*
0634 Find the Derangement of An Array Python, Java O(n) O(1) Medium math, 🔒, amazon AGAIN (not start)
0640 Solve the Equation Python, Java O(n) O(n) Medium math, regular expression, amazon, google, fb AGAIN*** (3)
0651 4 Keys Keyboard Python, Java O(n) O(n) Medium math, 🔒, DP, google, amazon, microsoft AGAIN (not start)
0672 Bulb Switcher II Python, Java O(1) O(1) Medium math, only 6 distinct states after the first 3 lights, trick, microsoft AGAIN (not start)
0728 Self Dividing Numbers Python, Java O(n) O(1) Easy math, check that each digit divides the number, basic AGAIN
0754 Reach a Number Python, Java O(logn) O(1) Medium math, walk to the first triangular number >= target then fix parity, good trick, google, amazon OK*
0775 Global and Local Inversions Python, Java O(n) O(1) Medium math, trick, string, amazon, google AGAIN** (not start) (3)
0779 K-th Symbol in Grammar Python, Java O(1) O(1) Medium math, brute force, binary, recursion, fb, amazon, google, apple AGAIN*** (1)
0781 Rabbits in Forest Python, Java O(n) O(n) Medium math, group rabbits by their answer, ceil division, good trick AGAIN (not start)
0789 Escape The Ghosts Python, Java O(n) O(1) Medium math, compare Manhattan distances, trick, google AGAIN
0800 Similar RGB Color Python, Java O(1) O(1) Easy math, 🔒, google AGAIN (not start)
0812 Largest Triangle Area Python, Java O(n^3) O(1) Easy math, shoelace formula over all triples, geometry, google AGAIN (not start)
0829 Consecutive Numbers Sum Python, Java O(sqrt(n)) O(1) Medium math, count factorizations n = k * m + k(k - 1) / 2, good trick, google, amazon, uber AGAIN
0836 Rectangle Overlap Python, Java O(1) O(1) Easy math, similar as 223. Rectangle Area, amazon, google, fb, apple, microsoft, uber, bloomberg AGAIN (2)
0858 Mirror Reflection Python, Java O(1) O(1) Medium math, LCM / parity reasoning, good trick, google, fb AGAIN (not start)
0866 Prime Palindrome Python, Java O(n^(1/2) * (logn + n^(1/2))) O(logn) Medium math, generate palindromes then test primality, even-length ones divide by 11, amazon AGAIN***
0867 Transpose Matrix Java O(m * n) O(m * n) Medium math, duplicate of LC 868, matrix, basic, array, simulation, amazon, apple, neetcode250 AGAIN*
0883 Projection Area of 3D Shapes Python, Java O(n^2) O(1) Easy math, xy = count of non-zero cells, yz = column max, zx = row max, matrix AGAIN
0891 Sum of Subsequence Widths Python, Java O(nlogn) O(1) Hard math, sort, each element contributes as max/min weighted by powers of 2, amazon AGAIN (not start)
0907 Sum of Subarray Minimums Python, Java O(n) O(n) Medium math, trick, LC 084, LC 2104, Ascending Stack, amazon, array, dp, google, uber AGAIN**** (1)
0908 Smallest Range I Python, Java O(n) O(1) Easy math, max(0, max - min - 2k), basic OK* (2)
0910 Smallest Range II Python, Java O(nlogn) O(1) Medium math, sort then try every split point, greedy, good trick, apple AGAIN (not start)
0914 X of a Kind in a Deck of Cards Python, Java O(nlogn) O(n) Easy math, gcd of all group counts must be >= 2, Counter, google AGAIN (not start)
0963 Minimum Area Rectangle II Python, Java O(n^2) O(n) Medium math, hashmap keyed by (center, diagonal length), geometry, google, amazon, fb AGAIN (not start)
0970 Powerful Integers Python, Java O((logn)^2) O® Easy math, basic, amazon AGAIN* (2)
1015 Smallest Integer Divisible by K Java O(k) O(1) Medium math, track remainder of 1, 11, 111 … mod k, pigeonhole, google, apple AGAIN (not start)
1071 Greatest Common Divisor of Strings Java O(m + n) O(1) Easy math, if s1 + s2 == s2 + s1 the answer is the prefix of length gcd(m, n), good trick, amazon, neetcode250 AGAIN (not start)
1342 Number of Steps to Reduce a Number to Zero Python, Java O(logn) O(1) Easy math, gra*, google, amazon, apple, microsoft ok
1492 The kth Factor of n Python, Java O(sqrt(n)) O(1) Medium math, amazon AGAIN (not start)
1979 Find Greatest Common Divisor of Array Python, Java O(n + log(min)) O(1) Easy math, GCD not start
2013 Detect Squares Java add: O(1), count: O(n) O(n) Medium math, hashmap of point counts, iterate the diagonal point, array, design, google, neetcode150 not start
2028 Find Missing Observations Python O(n + m) O(n) Medium math, distribute the missing sum evenly: feasible iff n <= need <= 6 * n, divmod, LC weekly AGAIN (1)
2029 Stone Game IX Python O(n) O(1) Medium math, game theory on counts mod 3, parity of c0 picks the rule, good trick, LC weekly AGAIN (1)
2507 Smallest Value After Replacing With Sum of Prime Factors Java O(logn * sqrt(n)) O(1) Medium math, LC weekly again (1)
2614 Prime In Diagonal Java O(n * sqrt(M)) O(1) Easy math, diagonal matrix, good basic, LC weekly again**** (1)
2807 Insert Greatest Common Divisors in Linked List Java O(n * log(maxV)) O(1) Medium math, walk the list and insert gcd nodes, linked list, basic, neetcode250 OK
2961 Double Modular Exponentiation Java O(q * logE) O(1) Medium math, weekly375 AGAIN (1)
3091 Apply Operations to Make Sum of Array Greater Than or Equal to k Java O(1) O(1) Medium math, LC weekly AGAIN (1)
3190 Find Minimum Operations to Make All Elements Divisible by Three Java O(n) O(1) Easy math, LC weekly OK
3194 Minimum Average of Smallest and Largest Elements Java O(nlogn) O(1) Easy math, LC weekly, array, two pointers, sort OK
3993 Maximum Value of an Alternating Sequence Python, Java O(1) O(1) Medium math, LC weekly, good trick again**** (1)
4053 Minimum Operations to Make Every Element Palindromic Python O(P log P + n log P) O(P) Medium math, +2/-2 KEEPS PARITY — BISECT THE NEAREST SAME-PARITY PALINDROME, precomputed palindrome table (a palindrome is fixed by its first half), complex, LC weekly AGAIN (not start)

Scan Line

# Title Solution Time Space Difficulty Note Status
1943 Describe the Painting Java O(nlogn) O(n) Medium scan line, treeMap, delta, good basic, google, array, hash table, sort AGAIN***** (1)(MUST)
4056 Number of Intersecting Interval Pairs I Python O(n^2) O(1) Easy scan line, sort by start + double loop, break once start[j] > end[i], closed intervals (shared endpoint counts), LC weekly AGAIN(1)
4057 Number of Intersecting Interval Pairs II Python O(nlogn) O(n) Medium scan line, each start meets every open interval -> res += active, starts before ends at same pos, NOT max C(active,2), LC 4056, LC weekly AGAIN****** (2)

Sort

# Title Solution Time Space Difficulty Note Status
0075 Sort Colors Python, Java O(n) O(1) Medium sort, Tri Partition, two pointers, microsoft, fb, google, amazon, apple, uber, bloomberg, neetcode250, top100liked OK** (4)
0088 Merge Sorted Array Python, Java O(m + n) O(1) Easy sort, good basic, merge, two pointers, microsoft, amazon, fb, google, apple, uber, linkedin, bloomberg, neetcode250 AGAIN************* (8) (MUST)
0128 Longest Consecutive Sequence Python, Java O(n) O(n) Medium sort, card, 2 pointers, sliding window, O(N), amazon, array, hash table, union find, google, fb, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN*************** (7) (MUST)
0147 Insertion Sort List Python, Java O(n^2) O(1) Medium sort, trick, amazon, apple, microsoft AGAIN* (2)
0148 Sort List Python, Java O(nlogn) O(logn) Medium sort, basic, check # 21 Merge Two Sorted Lists, google, amazon, fb, apple, microsoft, uber, top100liked AGAIN** (2)
0164 Maximum Gap Java O(n) O(n) Medium sort, bucket sort / radix sort, pigeonhole on the gap, google, amazon, fb, apple, microsoft OK
0179 Largest Number Python, Java O(nlogn) O(n) Medium sort, good basic, sort with lambda, amazon, google, fb, apple, microsoft, uber AGAIN************ (3)
0252 Meeting Rooms Python, Java O(nlogn) O(n) Easy sort, LC 554, uber, amazon, fb, google, microsoft, bloomberg, blind75 OK*** (4) (but again)
0253 Meeting Rooms II Python, Java O(nlogn) O(n) Medium sort, card, LC 2406, priority queue (min-heap), scanning line, trick, booking.com, good, uber, amazon, google, fb, apple, microsoft, bloomberg, blind75 AGAIN************ (5) (MUST)
0274 H-Index Python, Java O(n) O(n) Medium sort, Counting Sort, good trick, fb, google, amazon, apple, bloomberg AGAIN***** (3)
0280 Wiggle Sort Python, Java O(n) O(1) Medium sort, 🔒, google, fb, amazon, microsoft OK*** (3)
0324 Wiggle Sort II Python, Java O(n) on average O(1) Medium sort, variant of Sort Colors, Tri Partition, google, amazon, fb AGAIN** (2)
0327 Count of Range Sum Java O(nlogn) O(n) Hard sort, merge sort with counting, BIT, segment tree, array, binary search, divide and conquer, google, amazon AGAIN (not start)
0347 Top K Frequent Elements Python, Java O(n) O(n) Medium sort, HashMap, Heap, yelp, amazon, fb, GOOD basic, google, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN******** (4)
0406 Queue Reconstruction by Height Python, Java O(n^2) O(n) Medium sort, basic, trick, sort by key, insert, google, next_big_val, amazon, fb, apple, microsoft, bloomberg AGAIN********* (5)
0451 Sort Characters By Frequency Python, Java O(nlogn) O(n) Medium sort, collections.Counter(s).most_common, sorted(count_dict.items() with lambda, good basic, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg OK* (4)
0493 Reverse Pairs Java O(nlogn) O(n) Hard sort, merge sort with counting, or BIT, good trick, array, binary search, divide and conquer, google, amazon, fb, microsoft, uber AGAIN (not start)
0692 Top K Frequent Words Python, Java O(n + klogk) on average O(n) Medium sort, good basic, Quick Select, Heap, Bucket Sort, heapq, yelp, uber, amazon, fb, google, apple, microsoft, linkedin, bloomberg OK***** (5)
0912 Sort an Array Python, Java O(nlogn) O(n) Medium sort, merge sort, quick sort, apple, amazon, microsoft, neetcode250 AGAIN** (1)
0937 Reorder Data in Log Files Python, Java O(nlogn * l) O(n * l) Medium sort, good basic, string, amazon, google, apple OK**** (3)(again!!!)
0969 Pancake Sorting Python, Java O(n^2) O(1) Medium sort, fb, google, amazon, apple, microsoft, uber AGAIN********** (4)
0973 K Closest Points to Origin Python, Java O(n) on average O(1) Medium sort, good trick, sort with func, PQ, Heap, amazon, google, fb, apple, microsoft, uber, linkedin, neetcode150 OK***** (3)(but again)
0976 Largest Perimeter Triangle Python, Java O(nlogn) O(1) Easy sort, sort descending then take the first valid triple, greedy, basic OK* (2)
1057 Campus Bike Java O(m * nlog(m * n)) O(m * n) Medium sort, sort all (dist, worker, bike) triples or bucket by distance, google, amazon AGAIN
1066 Campus Bike II Java O(m * 2^n) O(2^n) Medium sort, bitmask dp over bikes, min cost assignment, google, array, backtracking, amazon AGAIN
1152 Analyze User Website Visit Pattern Python, Java O(nlogn + u * m^3) O(n + u * m^3) Medium sort, itertools.combinations, brute force, set, amazon AGAIN***** (2) (not start)
1329 Sort the Matrix Diagonally Java O(m * nlog(min(m, n))) O(m * n) Medium sort, group cells by (i - j), sort each diagonal, PQ, hashMap, google, amazon, fb, microsoft AGAIN (not start)
1877 Minimize Maximum Pair Sum in Array Java O(nlogn) O(1) Medium sort, good basic, google AGAIN*** (1)
2021 Brightest Position on Street Python, Java O(nlogn) O(n) Medium sort, LC 253 meeting room II, PQ, prefix, diff array, scanning line, trick, amazon AGAIN*********** (3) (MUST)
2284 Sender With Largest Word Count Java O(n) O(n) Medium sort, LC 347, hashmap, sort by (count, name), good basic, array, string OK
2345 Finding the Number of Visible Mountains Java O(nlogn) O(n) Medium sort, monotonic stack, hashmap, interval cover AGAIN (not start)
2402 Meeting Rooms III Java O(nlogn) O(n) Hard sort, LC 253, two heaps (free rooms / busy rooms), sort by start, good trick, neetcode250 AGAIN (not start)
2659 Make Array Empty Java O(nlogn) O(n) Hard sort, BIT / sorted index scan, good trick, weekly_103 AGAIN (not start)

Two Pointers

# Title Solution Time Space Difficulty Note Status
0019 Remove Nth Node From End of List Python, Java O(n) O(1) Medium two pointers, good basic, MUST, linked list, fb, google, amazon, apple, microsoft, uber, blind75, top100liked AGAIN********** (4) (MUST)
0042 Trapping Rain Water Python, Java O(n) O(1) Hard two pointers, stack, prefix-suffix array, brute force, amazon, apple, google, fb, microsoft, uber, bloomberg, neetcode150, top100liked AGAIN******** (3)
0086 Partition List Python, Java O(n) O(1) Medium two pointers, two dummy heads then splice, linked list, good basic, amazon, fb, apple, microsoft OK*
0141 Linked List Cycle Python, Java O(n) O(1) Easy two pointers, basic, amazon, fb, linked list, check #142, google, apple, microsoft, linkedin, bloomberg, blind75, top100liked OK** (5)
0142 Linked List Cycle II Python, Java O(n) O(1) Medium two pointers, linked list, check #141, google, amazon, fb, apple, microsoft, linkedin, top100liked AGAIN****** (4) (again!)
0143 Reorder List Python, Java O(n) O(1) Medium two pointers, card, LC 021, 206, 876, good trick, inverse linkedlist, merge linkedlist, fb, amazon, google, apple, microsoft, uber, blind75 AGAIN************** (6) (MUST)
0167 Two Sum II - Input array is sorted Python, Java O(n) O(1) Medium two pointers, dict, binary search, good basic, amazon, google, fb, apple, microsoft, neetcode150 OK* (6)
0214 Shortest Palindrome Java O(n) O(n) Hard two pointers, KMP failure function on s + ‘#’ + reverse(s), good trick, string, rolling hash, google, amazon, fb, apple, microsoft AGAIN (not start)
0259 3Sum Smaller Python, Java O(n^2) O(1) Medium two pointers, 🔒, LintCode, good trick, google, fb, check #015 3 Sum, check #001 two sum AGAIN******** (4)
0283 Move Zeroes Python, Java O(n) O(1) Easy two pointers, basic, trick, shopee, fb, google, amazon, apple, microsoft, uber, bloomberg, top100liked AGAIN********* (6)
0344 Reverse String Python, Java O(n) O(1) Easy two pointers, swap from both ends in place, basic, google, amazon, fb, apple, microsoft, uber, linkedin, bloomberg, neetcode250 OK
0345 Reverse Vowels of a String Python, Java O(n) O(1) Easy two pointers, google, amazon, fb, apple OK** (1)
0349 Intersection of Two Arrays Python, Java O(m + n) O(min(m, n)) Easy two pointers, EPI, Hash, Binary Search, fb, google, amazon, apple, microsoft, linkedin OK
0350 Intersection of Two Arrays II Python, Java O(m + n) O(1) Easy two pointers, EPI, Hash, Binary Search, good basic, fb, google, amazon, apple, microsoft, uber, linkedin OK** (3)
0360 Sort Transformed Array Python, Java O(n) O(1) Medium two pointers, trick, 🔒, google, fb AGAIN*** (3)
0457 Circular Array Loop Python, Java O(n) O(1) Medium two pointers, fast/slow pointers per start, same-direction check, good trick, google, amazon, apple, microsoft AGAIN (not start)
0567 Permutation in String Python, Java O(n) O(1) Medium two pointers, sliding window, counter, hashmap, good basic, microsoft, fb, google, amazon, apple, uber, neetcode150 AGAIN********* (8)(MUST)
0611 Valid Triangle Number Python, Java O(n^2) O(1) Medium two pointers, sort then two pointers, count valid triples, good trick, amazon, apple, microsoft, uber, linkedin, bloomberg AGAIN (not start)
0777 Swap Adjacent in LR String Python, Java O(n) O(1) Medium two pointers, L only moves left, R only moves right, relative order preserved, good trick, google AGAIN (not start)
0826 Most Profit Assigning Work Python, Java O(mlogm + nlogn) O(n) Medium two pointers, trick, good basic, zip+sorted, google, amazon, uber OK*
0844 Backspace String Compare Python, Java O(m + n) O(1) Easy two pointers, good basic, stack, google, fb, amazon, apple, microsoft, uber OK* (4)
0862 Shortest Subarray with Sum at Least K Python, Java O(n) O(n) Hard two pointers, prefix sum + monotonic deque, LC 209, good trick, new, array, binary search, queue, google, amazon, fb, apple, microsoft
0876 Middle of the Linked List Python, Java O(n) O(1) Easy two pointers, basic, amazon, apple, google, linkedlist, fb, microsoft OK* (2)
0904 Fruit Into Baskets Python, Java O(n) O(1) Medium two pointers, slide window, google, array, hash table, amazon, apple AGAIN*** (1)
0930 Binary Subarrays With Sum Python, Java O(n) O(1) Medium two pointers, trick, array, hash table, sliding window AGAIN* (2) (not start)
0977 Squares of a Sorted Array Python, Java O(n) O(1) Easy two pointers, two pointers from both ends, LC 88, basic, google, amazon, fb, apple, microsoft, uber OK
0986 Interval List Intersections Python, Java O(n) O(1) Medium two pointers, scanning line, good basic, google, amazon, fb, apple, uber AGAIN********* (1) (MUST)
1023 Camelcase Matching Java O(n) O(1) Medium two pointers, dp, good basic, google, amazon AGAIN****** (1)
1055 Shortest Way to Form String Python, Java O(n * m) O(1) Medium two pointers, google, fb again
1147 Longest Chunked Palindrome Decomposition Java O(n) O(1) Hard two pointers, rolling hash, google again (not start)
1151 Minimum Swaps to Group All 1’s Together Python, Java O(n) O(1) Medium two pointers, good basic, Deque (Double-ended Queue), amazon, array, sliding window AGAIN***** (not start )
1229 Meeting Scheduler Java O(n) O(1) Medium two pointers, sort amazon, google, amazon, apple, microsoft AGAIN***** (not start )
1498 Number of Subsequences That Satisfy the Given Sum Condition Python O(nlogn) O(n) Medium two pointers, sort (only min + max matter), 2^(r - l) per left end, precomputed powers, good trick, google, amazon, fb AGAIN(1)
1768 Merge Strings Alternately Java O(m + n) O(m + n) Easy two pointers, merge two strings alternately then append the rest, basic, google, uber, neetcode250 OK
1963 Minimum Number of Swaps to Make the String Balanced Python, Java O(n) O(1) Medium two pointers, good basic, greedy, stack, amazon, fb, microsoft AGAIN******** (2)
3191 Minimum Operations to Make Binary Array Elements Equal to One I Java O(n) O(1) Medium two pointers, greedy flip a window of 3, sliding window, LC 995, good basic, array, bit manipulation, queue Again* (2)
3192 Minimum Operations to Make Binary Array Elements Equal to One II Java O(n) O(1) Medium two pointers, LC 3191, greedy prefix flip with a running parity counter, good trick, array, dp Again* (2)

Recursion

# Title Solution Time Space Difficulty Note Status
0010 Regular Expression Matching Python, Java O(m * n) O(m * n) Hard recursion, dp, 2D dp, LC 44, fb, google, amazon, apple, microsoft, uber, bloomberg, neetcode150 AGAIN (not start)
0095 Unique Binary Search Trees II Python, Java O(4^n / n^(3/2)) O(4^n / n^(3/2)) Medium recursion, DP, # BSTs = combinations of left × right, amazon, google, apple, backtracking, tree, fb, microsoft AGAIN***************** (1)(MUST)
0098 Validate Binary Search Tree Python, Java O(n) O(h) Medium recursion, bfs, dfs, BST, microsoft, amazon, fb, google, apple, linkedin, bloomberg, blind75, top100liked AGAIN****************** (11)
0100 Same Tree Python, Java O(n) O(h) Easy recursion, dfs, bfs, good basic, amazon, tree, google, fb, apple, microsoft, linkedin, bloomberg, blind75 OK****** (5) (but again)
0104 Maximum Depth of Binary Tree Python, Java O(n) O(h) Easy recursion, card, DFS, BFS, good basic, amazon, top down, bottom up, LC 111, tree, google, fb, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN************ (5)(MUST)
0105 Construct Binary Tree from Preorder and Inorder Traversal Python, Java O(n) O(n) Medium recursion, trick, check # 106, BST, microsoft, fb, google, amazon, apple, uber, bloomberg, blind75, top100liked AGAIN********* (9)
0106 Construct Binary Tree from Inorder and Postorder Traversal Python, Java O(n) O(n) Medium recursion, trick, check # 105, BST, microsoft, fb, google, amazon AGAIN******* (6)
0108 Convert Sorted Array to Binary Search Tree Python, Java O(n) O(logn) Easy recursion, good basic, BST, build tree from sorted array, DFS, LC 109, google, amazon, fb, apple, microsoft, bloomberg, top100liked AGAIN************* (2) (MUST)
0109 Convert Sorted List to Binary Search Tree Python, Java O(n) O(logn) Medium recursion, list, BST, good concept, fb, google, amazon, microsoft, bloomberg AGAIN*** (3)
0110 Balanced Binary Tree Python, Java O(n) O(h) Easy recursion, card, good trick, LC 104, dfs, bfs, amazon, fb, google, top-down, bottom-up recursion, tree, binary tree, apple, microsoft, bloomberg, neetcode150 AGAIN************** (8)(MUST)
0111 Minimum Depth of Binary Tree Python, Java O(n) O(h) Easy recursion, good basic, dfs, BST, amazon, fb, LC 104, bfs, google, apple, microsoft AGAIN******** (5)
0114 Flatten Binary Tree to Linked List Python, Java O(n) O(h) Medium recursion, good trick, Reverse Preorder DFS, dfs, microsoft, fb, linked list, stack, tree, google, amazon, apple, uber, bloomberg, top100liked AGAIN*************** (6)(MUST)
0116 Populating Next Right Pointers in Each Node Python, Java O(n) O(1) Medium recursion, good basic, bfs, dfs, tree, AGAIN, fb, amazon, linked list, google, apple, microsoft, bloomberg AGAIN************ (6)
0117 Populating Next Right Pointers in Each Node II Python, Java O(n) O(h) Medium recursion, good basic, prev node, Populating Next Right Pointers in Each Node I, bfs, linked list, amazon, fb, google, tree, dfs, microsoft, bloomberg AGAIN************* (4)
0129 Sum Root to Leaf Numbers Python, Java O(n) O(h) Medium recursion, path sum, dfs, good basic, fb, tree, binary tree, google, amazon, apple, microsoft AGAIN******* (5)
0156 Binary Tree Upside Down Python, Java O(n) O(1) Medium recursion, 🔒, tree, dfs, binary tree, linkedin AGAIN (not start)
0241 Different Ways to Add Parentheses Python, Java O(n * 4^n / n^(3/2)) O(n * 4^n / n^(3/2)) Medium recursion, complex, dp, Memoization, google, amazon, fb, microsoft AGAIN (not start)
0298 Binary Tree Longest Consecutive Sequence Python, Java O(n) O(h) Medium recursion, LC 437, good basic, prev node, bfs, dfs, tree, 🔒, google, binary tree, amazon, fb, uber AGAIN *************** (6) (MUST)
0333 Largest BST Subtree Python, Java O(n) O(h) Medium recursion, 🔒, dfs, post-order, return (isBST, min, max, size), LC 98, dp, tree, google, amazon, fb, apple, microsoft AGAIN (not start)
0337 House Robber III Python, Java O(n) O(h) Medium recursion, good trick, dp + dfs, tree DP, rob/not-rob state, LC 198, amazon, google, fb, microsoft, uber, neetcode250 AGAIN********** (3)(MUST)
0395 Longest Substring with At Least K Repeating Characters Python, Java O(26 * n) O(1) Medium recursion, slide window, DIVIDE AND CONQUER, good trick, fb, google, amazon, apple, microsoft, uber AGAIN************ (4)
0404 Sum of Left Leaves Python, Java O(n) O(h) Easy recursion, tree, bfs, dfs, amazon, google, fb, apple AGAIN**** (4)
0437 Path Sum III Python, Java O(n) O(h) Medium recursion, LC 298, prefix sum, hashmap, dfs, path sum, good trick, uber, amazon, fb, tree, binary tree, google, apple,top100liked AGAIN*********** (8) (MUST)
0501 Find Mode in Binary Search Tree Java O(n) O(h) Medium recursion, dfs, bfs, LC 98, tree, bst, google, amazon OK (1)
0544 Output Contest Matches Python, Java O(nlogn) O(n) Medium recursion, 🔒, recursively pair first with last, string build, good trick, google AGAIN
0549 Binary Tree Longest Consecutive Sequence II Python, Java O(n) O(h) Medium recursion, 🔒, tree, dfs, binary tree, google, amazon, fb, apple AGAIN (not start)
0669 Trim a Binary Search Tree Python, Java O(n) O(h) Medium recursion, good basic, BST trim, dfs, amazon, google, fb, apple, microsoft, bloomberg AGAIN*********** (6)(MUST)
0671 Second Minimum Node In a Binary Tree Python, Java O(n) O(h) Easy recursion, dfs, tree, binary tree, google, microsoft, uber, linkedin OK* (2)
0753 Cracking the Safes Java O(k^n * n) O(k^n * n) Hard recursion, de Bruijn sequence, Hierholzer / dfs over states, google, string, graph, apple AGAIN (not start)
1145 Binary Tree Coloring Game Java O(n) O(h) Medium recursion, tree, color, google, dfs, binary tree AGAIN***** (2)
# Title Solution Time Space Difficulty Note Status
0033 Search in Rotated Sorted Array Python, Java O(logn) O(1) Medium binary search, LC 153, 852, good basic, check # 81 Search in Rotated Sorted Array II, rotation array, uber, amazon, fb, google, apple, microsoft, linkedin, bloomberg, blind75, top100liked AGAIN************ (6) (MUST)
0034 Find First and Last Position of Element in Sorted Array Python, Java O(logn) O(1) Medium binary search, amazon, fb, google, apple, uber, microsoft, linkedin, bloomberg, top100liked AGAIN************** (4) (MUST)
0034 Search for a Range Python, Java O(logn) O(1) Medium binary search, duplicate of LC 34, lower bound + upper bound binary search, google, amazon, fb, apple, microsoft, uber, linkedin, bloomberg, top100liked AGAIN*
0035 Search Insert Position Python, Java O(logn) O(1) Medium binary search, LC 436, binary search on left, good basic, google, amazon, fb, apple, bloomberg, neetcode250, top100liked AGAIN************ (2) (MUST)
0069 Sqrt(x) Python, Java O(logn) O(1) Medium binary search, math, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg, neetcode250 OK* (4)
0074 Search a 2D Matrix Python, Java O(logm + logn) O(1) Medium binary search, binary search in 2D array, flatten matrix, amazon, google, fb, apple, microsoft, uber, neetcode150, top100liked OK**** (BUT AGAIN)(3)
0081 Search in Rotated Sorted Array II Python, Java O(logn) O(1) Medium binary search, check # 33 Search in Rotated Sorted Array first, array, fb, amazon, linkedin, google, apple, microsoft, bloomberg, neetcode250 OK***** (6)
0153 Find Minimum in Rotated Sorted Array Python, Java O(logn) O(1) Medium binary search, card, LC 33, ascending array, good basic, amazon, google, fb, apple, microsoft, uber, linkedin, blind75, top100liked AGAIN**************** (10)(MUST)
0154 Find Minimum in Rotated Sorted Array II Java O(logn) O(1) Medium binary search, LC 153, google, amazon, fb, microsoft, uber AGAIN (not start)
0162 Find Peak Element Python, Java O(logn) O(1) Medium binary search, good trick, recursive, iterative binary search, microsoft, google, fb, amazon, apple, uber, bloomberg AGAIN********** (6)
0222 Count Complete Tree Nodes Python, Java O((logn)^2) O(logn) Easy binary search, google, tree, amazon, fb, microsoft OK (again)
0275 H-Index II Python, Java O(logn) O(1) Medium binary search, similar as # 274 H-Index, fb, google AGAIN**** (3)
0278 First Bad Version Python, Java O(logn) O(1) Easy binary search, good basic, LintCode, fb, google, amazon, apple, microsoft, uber OK*** (5) (MUST)
0300 Longest Increasing Subsequence Python, Java O(nlogn) O(n) Medium binary search, card, Patience Sorting, DP good basic, LintCode, 1D DP, LIS, amazon, fb, google, apple, microsoft, uber, blind75, top100liked AGAIN******************* (15) (MUST)
0315 Count of Smaller Numbers After Self Python, Java O(nlogn) O(n) Hard binary search, BST, BIT, google, amazon, fb, apple, microsoft, uber again*
0367 Valid Perfect Square Python, Java O(logn) O(1) Easy binary search, good basic, similar as # 69 Sqrt(x), google, amazon, fb, microsoft, linkedin OK* (3)
0374 Guess Number Higher or Lower Python, Java O(logn) O(1) Easy binary search, classic binary search on the guess API, good basic, google, amazon, apple, neetcode250 OK*
0410 Split Array Largest Sum Python, Java O(nlog(sum)) O(1) Hard binary search, google, LC 1231, 1552, amazon, fb, apple, uber, neetcode250 AGAIN (not start)
0436 Find Right Interval Python, Java O(nlogn) O(n) Medium lower bound / binary search, LC 35, good basic, google, amazon AGAIN********** (3) (MUST)
0475 Heaters Python, Java O((m + n) * logn) O(1) Easy binary search, sort houses and heaters, binary search the nearest heater, two pointers, google AGAIN (not start)
0540 Single Element in a Sorted Array Python, Java O(logn) O(1) Medium binary search, binary search on even indices, pair-XOR check, good trick, google, amazon, fb, apple, microsoft OK*
0564 Find the Closest Palindrome Java O(n) O(n) Hard binary search, n = number of digits, build 5 palindrome candidates around the prefix, google, math, string, amazon, fb, apple, microsoft AGAIN(not start)
0658 Find K Closest Elements Python, Java O(logn + k) O(1) Medium binary search, good trick, PQ, binary search find window start point, amazon, fb, google, apple, microsoft, uber, bloomberg, neetcode250 AGAIN ********************** (9) (MUST)
0704 Binary Search Python O(logn) O(1) Easy binary search, the closed-interval template, while l <= r, basic, google, amazon, fb, apple, microsoft, uber, neetcode150, neetcode250 AGAIN(1)
0744 Find Smallest Letter Greater Than Target Python, Java O(logn) O(1) Easy binary search, upper bound binary search with wraparound, basic, amazon, linkedin OK*
0774 Minimize Max Distance to Gas Station Python, Java O(nlog(maxD / eps)) O(1) Hard binary search, binary search on a real-valued answer, PQ, google AGAIN***** (1)
0852 Peak Index in a Mountain Array Python, Java O(logn) O(1) Medium binary search, LC 162, LC 33, amazon, google, fb, apple, microsoft, uber AGAIN****** (2)
0875 Koko Eating Bananas Python, Java O(nlogr) O(1) Medium binary search, left boundary, good basic, google, amazon, fb, apple, neetcode150 AGAIN******* (4)(MUST)
0894 All Possible Full Binary Trees Python, Java O(n * 4^n / n^(3/2)) O(n * 4^n / n^(3/2)) Medium binary search, dfs + memoization, Catalan number, only odd n has a full binary tree, dp, recursion, google, amazon, apple AGAIN (not start)
0911 Online Election Python, Java ctor: O(n)
query : O(logn)		 O(n) Medium binary search, prefix leader array + binary search on the query time, good basic, google, apple AGAIN (not start)
0981 Time Based Key-Value Store Python, Java set: O(1), get: O(logn) O(n) Medium binary search, dict, treeMap, floorKey, sort, apple, microsoft, amazon, google, fb, uber, neetcode150 AGAIN****** (2)
1011 Capacity To Ship Packages Within D Days Python, Java O(nlog(sum)) O(1) Medium binary search, good trick, amazon, apple, fb, microsoft, google, uber, neetcode250 AGAIN****** (3)
1060 Missing Element in Sorted Array Java O(logn) O(1) Medium binary search, brute force, good trick, google, amazon, fb, apple, bloomberg AGAIN**** (2)
1095 Find in Mountain Array Java O(logn) O(1) Hard binary search, LC 852 find the peak then binary search each side, MountainArray API, good trick, google, amazon, apple, neetcode250 AGAIN (not start)
1150 Check If a Number Is Majority Element in a Sorted Array Java O(logn) O(1) Easy binary search, lower + upper bound, count occurrences, fb AGAIN**** (1)
1231 Divide Chocolate Java O(nlog(sum)) O(1) Hard binary search, google, LC 2616, Maximize Minimum, LC 410, amazon, fb AGAIN***** (not start)
1283 Find the Smallest Divisor Given a Threshold Java O(nlog(max)) O(1) Medium binary search, binary search on the divisor, LC 875, good basic, google, amazon, uber AGAIN***** (not start)
1292 Maximum Side Length of a Square with Sum Less than or Equal to Threshold Python, Java O(m * nlog(min(m, n))) O(m * n) Medium binary search, 2D prefix-sum, good trick, google, amazon AGAIN******* (2)
1482 Minimum Number of Days to Make m Bouquets Java O(nlog(max)) O(1) Medium binary search, binary search on the day, greedily count adjacent runs, good basic, google AGAIN (not start)
1552 Magnetic Force Between Two Balls Java O(nlogn + nlog(max)) O(1) Medium binary search, LC 410, can distribute, google, amazon, uber AGAIN (1)
1760 Minimum Limit of Balls in a Bag Java O(nlog(max)) O(1) Medium binary search, binary search on the penalty, ceil(count / limit) - 1 operations, good trick AGAIN (1)
1889 Minimum Space Wasted From Packaging Python, Java O((m + n) * logn) O(n) Hard binary search, heap, prefix sum, amazon AGAIN (not start)
1891 Cutting Ribbons Java O(nlog(max)) O(1) Medium binary search, 🔒, binary search on the ribbon length, good basic, google, fb, uber AGAIN (not start)
2009 Minimum Number of Operations to Make Array Continuous Python, Java O(nlogn) O(n) Hard binary search, sliding window, dequeue, bisect.bisect_right, amazon, uber AGAIN (not start)
2554 Maximum Number of Integers to Choose From a Range I Java O(n) O(n) Medium binary search, hash set of banned values, greedily take the smallest, weekly 97 AGAIN (not start)
2594 Minimum Time to Repair Cars Java O(nlog(maxT)) O(1) Medium binary search, PQ, trick, weekly 100 AGAIN***** (1)
2616 Minimize the Maximum Difference of Pairs Java O(nlogn + nlog(max)) O(1) Medium binary search, LC weekly, good trick, Minimize the Maximum, LC 1231 AGAIN******* (1)
4008 Minimum Initial Strength to Defeat All Monsters Python, Java O(n + m + nlog(sum)) O(n) Medium binary search, LC weekly, good trick AGAIN* (1)

Binary Search Tree

# Title Solution Time Space Difficulty Note Status
0099 Recover Binary Search Tree Python, Java O(n) O(h) Medium BST, good trick, BST swap, DFS, inorder, Morris traversal, google, amazon, fb, apple, microsoft, uber AGAIN******************** (5)(MUST)
0220 Contains Duplicate III Python, Java O(nlogk) O(k) Medium BST, LC 219, sliding window with TreeSet or bucketing, good trick, array, sort, google, amazon, fb, apple, microsoft AGAIN (not start)
0230 Kth Smallest Element in a BST Python, Java O(max(h, k)) O(min(h, k)) Medium BST, good basic BST basic, DFS, BFS, STACK, amazon, google, fb, apple, microsoft, uber, bloomberg, blind75, top100liked OK********* (4)
0235 Lowest Common Ancestor of a Binary Search Tree Python, Java O(h) O(1) Medium BST, recursion, iteration, good basic, LCA, check # 236 Lowest Common Ancestor of a Binary Tree, amazon, fb, google, apple, microsoft, uber, linkedin, blind75 OK**************** (but again)(10)
0270 Closest Binary Search Tree Value Python, Java O(h) O(1) Easy BST, good basic, 🔒, microsoft, google, fb, amazon, linkedin, bloomberg OK***** (5)
0272 Closest Binary Search Tree Value II Java O(h + k) O(h + k) Hard BST, google, amazon, fb, closest val, binary search, linkedin AGAIN (1)
0285 Inorder Successor in BST Python, Java O(h) O(1) Medium BST, dfs, good basic, 🔒, amazon, fb, google, microsoft OK** (4)
0426 Convert Binary Search Tree to Sorted Doubly Linked List Python, Java O(n) O(h) Medium BST, recursion, tree, linked list, good basic UBER, lyft, amazon, google, fb, microsoft, uber AGAIN******* (5) (not start)
0449 Serialize and Deserialize BST Python, Java O(n) O(h) Medium BST, LC 297, dfs, bfs, good trick, serizlize deserizlize, tree, amazon, fb, google, apple, microsoft, uber, linkedin AGAIN************* (9) (MUST)
0450 Delete Node in a BST Python, Java O(h) O(h) Medium BST, card, good trick, tree, dfs, LC 1325, google, amazon, fb, apple, microsoft, uber, linkedin, neetcode250 AGAIN***************** (9) (MUST !!!)
0510 Inorder Successor in BST II Java O(h) O(1) Medium BST, parent, google, fb, apple, microsoft, bloomberg AGAIN** (1) (not start)
0530 Minimum Absolute Difference in BST Python, Java O(n) O(h) Easy BST, LC 783, google, apple AGAIN*
0700 Search in a Binary Search Tree Python, Java O(h) O(h) Easy BST, good basic, recursion, iteration amazon, google, amazon, apple, microsoft, uber AGAIN*** (1)
0776 Split BST Python, Java O(h) O(h) Medium BST, card, 🔒, recursive, iterative, DFS, split, trick, AGAIN, amazon, google, fb AGAIN************ (9)(MUST)
0783 Minimum Distance Between BST Nodes Python, Java O(n) O(h) Easy BST, LC 530, google, amazon OK*
0968 Binary Tree Cameras Python, Java O(n) O(h) Hard BST, node state, dfs, bottom up, post order, dp, greedy, microsoft, amazon, google, fb, apple AGAIN************* (3)(MUST)
1022 Sum of Root To Leaf Binary Numbers Python, Java O(n) O(h) Easy BST, good basic, LC 257, bst path, dfs, bfs, amazon, binary tree, google, apple AGAIN******** (1) (MUST)
1382 Balance a Binary Search Tree Python, Java O(n) O(n) Medium BST, LC 105, 106, inorder then rebuild, dfs, good trick, AVL tree, amazon, fb, apple AGAIN******** (2)
1597 Build Binary Expression Tree From Infix Expression Python, Java O(n) O(n) Hard BST, LC 224, recursive, iteration, stack, amazon, google, string AGAIN*** (1)
1644 Lowest Common Ancestor of a Binary Search Tree 2 Python, Java O(n) O(h) Medium BST, LC 235, 236, dfs, binary tree, google, amazon, fb, microsoft AGAIN (1)
# Title Solution Time Space Difficulty Note Status
0102 Binary Tree Level Order Traversal Python, Java O(n) O(n) Medium bfs, GOOD basic, dfs, uber, apple, amazon, fb, LC 199, google, microsoft, linkedin, bloomberg, blind75, top100liked AGAIN******* (8) (must)
0103 Binary Tree Zigzag Level Order Traversal Python, Java O(n) O(n) Medium bfs, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg OK
0107 Binary Tree Level Order Traversal II Python, Java O(n) O(n) Medium bfs, same as # 102 Binary Tree Level Order Traversal, google, amazon, apple, microsoft OK* (3)
0126 Word Ladder II Python, Java O(n * l^2) O(n * l) Hard bfs, complex, trick, dfs, dfs+bfs, check # 127 Word Ladder, amazon, google, fb, microsoft, uber, linkedin AGAIN*** (3) (not start)
0127 Word Ladder Python, Java O(n * d) O(d) Hard bfs, card, good basic, set, LC 126 Word Ladder II, uber, amazon, microsoft, fb, google, apple, linkedin, bloomberg, neetcode150 AGAIN**************** (12)(MUST)
0130 Surrounded Regions Python, Java O(m * n) O(m * n) Medium bfs, dfs, union find, good basic, amazon, google, fb, apple, microsoft, uber, neetcode150 AGAIN*********** (5)
0133 Clone Graph Python, Java O(n) O(n) Medium bfs, card, good trick, LC 138, graph, dfs, uber, google, amazon, fb, apple, microsoft, linkedin, blind75 AGAIN**************** (11) (MUST)
0207 Course Schedule Python, Java O(V + E) O(E) Medium bfs, card, Topological Sort, LC 210, good trick, dfs, amazon, fb, google, apple, microsoft, uber, linkedin, blind75, top100liked AGAIN**************** (15) (MUST)
0210 Course Schedule II Python, Java O(V + E) O(E) Medium bfs, Topological Sort, LC 207, dfs, amazon, fb, google, apple, microsoft, uber, neetcode150 AGAIN********* (10) (again)
0261 Graph Valid Tree Python, Java O(V + E) O(V + E) Medium bfs, card, union find, dfs, grpah, 🔒, graph, google, amazon, fb, microsoft, linkedin, blind75 AGAIN************* (12)(MUST)
0286 Walls and Gates Python, Java O(m * n) O(g) Medium bfs, 🔒, dfs, good basic, google, amazon, fb, apple, microsoft, uber, neetcode150 AGAIN******** (8)
0310 Minimum Height Trees Python, Java O(n) O(n) Medium bfs, good trick, undirected graph, topo sort, Kahn algo, google, amazon, fb, apple, microsoft, neetcode250 AGAIN******* (5)
0317 Shortest Distance from All Buildings Java O(m^2 * n^2) O(m * n) Hard bfs, multi-source BFS, total Path, cnt matrix, good trick, google, amazon, fb, microsoft, uber AGAIN*********** (1)(must)
0407 Trapping Rain Water II Java O(m * nlog(m * n)) O(m * n) Hard bfs, PQ, google, amazon, fb, apple, microsoft AGAIN (not start)
0429 N-ary Tree Level Order Traversal Java O(n) O(n) Medium bfs, PQ, google, amazon, microsoft AGAIN*** (1)
0433 Minimum Genetic Mutation Python, Java O(n * b) O(b) Medium bfs, check # 127 Word Ladder, good basic, google, amazon, uber AGAIN*** (3)
0444 Sequence Reconstruction Python, Java O(n + m) O(n) Medium bfs, good trick, Topological Sort, google, airbnb, array, graph AGAIN******* (4) (not start)
0490 The Maze Python, Java O(max(r, c) * w) O(w) Medium bfs, basic, dfs, amazon, fb, google, microsoft, uber AGAIN**** (5)
0499 The Maze III Python, Java O(m * n * max(m, n) * log(m * n)) O(m * n) Medium bfs, Dijkstra with lexicographically smallest path, roll until a wall, good trick, google, microsoft AGAIN (not start)
0505 The Maze II Python, Java O(max(r, c) * wlogw) O(w) Medium bfs, Dijkstra, google, fb, amazon AGAIN********* (7)(MUST)
0542 01 Matrix Python, Java O(m * n) O(m * n) Medium bfs, multi-source BFS, BFS get min dist, google, LC 994, 1765, amazon, fb, apple, microsoft, uber AGAIN************* (MUST) (4)
0666 Path Sum IV Python, Java O(n) O(n) Medium bfs, 🔒, encode (depth, position) into a hashmap then dfs, tree, array, fb AGAIN* (3) (not start)
0675 Cut Off Trees for Golf Event Python, Java O((m * n)^2) O(m * n) Hard bfs, good trick, tree, mult-source BFS, shortest path, amazon, google, apple AGAIN**************** (3)(must)
0742 Closest Leaf in a Binary Tree Python, Java O(n) O(n) Medium bfs, Graph, bfs+dfs, search, good trick, amazon, google, fb AGAIN************** (7)(MUST)
0743 Network Delay Time Python, Java O(E * logV) O(V + E) Medium bfs, Dijkstra, Bellman-Ford, shortest path from one source, google, amazon, microsoft, uber, neetcode150 AGAIN **** (3)
0752 Open the Lock Python, Java O(k * n^k + d) O(k * n^k + d) Medium bfs, LC 863, google, amazon, fb, apple, uber, neetcode250 AGAIN (not start)
0787 Cheapest Flights Within K Stops Python, Java O(E * logV) O(E) Medium bfs, Dijkstra's algorithm, dfs, graph, priority queue, amazon, apple, google, airbnb, fb, microsoft, uber, bloomberg, neetcode150 AGAIN****** (4)
0815 Bus Routes Python, Java O(V + E) O(V + E) Hard bfs, shortest route, graph, amazon, google, good trick, fb, uber AGAIN****** (3)
0864 Shortest Path to Get All Keys Python, Java O(m * n * 2^k) O(m * n * 2^k) Hard bfs, Dijkstra, Permutations, amazon, google AGAIN (not start)
0886 Possible Bipartition Python, Java O(V + E) O(V + E) Medium bfs, LC 785, graph, dfs, union find, fb, google, amazon, apple, microsoft AGAIN********** (6)
0934 Shortest Bridge Python, Java O(n^2) O(n^2) Medium bfs, BFS+DFS, multi-src BFS, good trick, google, amazon, fb, apple, microsoft, uber AGAIN************* (2)
0967 Numbers With Same Consecutive Differences Python, Java O(2^n) O(2^n) Medium bfs, good trick, uber AGAIN** (3)
0994 Rotting Oranges Python, Java O(m * n) O(m * n) Medium bfs, dp amazon, good trick, LC 542, google, amazon, fb, apple, microsoft, neetcode150, top100liked AGAIN********* (MUST) (2)
1091 Shortest Path in Binary Matrix Java O(n^2) O(n^2) Medium bfs, google, amazon, fb, microsoft, uber AGAIN (not start)
1110 Delete Nodes And Return Forest Python, Java O(n) O(n) Medium bfs, pre+post order DFS, 2 states, prune, tree, google, array, hash table, amazon, fb AGAIN************ (4)(MUST)
1136 Parallel Courses Python O(V + E) O(V + E) Medium bfs, Topological Sort, Kahn algo, BFS level == 1 semester, 🔒, LC 207, LC 210, graph, google AGAIN (1)
1162 As Far from Land as Possible Python, Java O(n^2) O(n^2) Medium bfs, muti-source bfs, good basic, amazon, google, fb, microsoft AGAIN********* (3)(MUST)
1197 Minimum Knight Moves Java O(n^2) O(n^2) Medium bfs, google, amazon, fb, apple, microsoft OK (1)
1530 Number of Good Leaf Nodes Pairs Python, Java O(n * d^2) O(n) Medium bfs, DFS, node pair, graph, good trick, tree, binary tree, google AGAIN************ (2)(MUST)
1730 Shortest Path to Get Food Python, Java O(m * n) O(m * n) Medium bfs, shortest path, amazon, google OK (2)
1765 Map of Highest Peak Java O(m * n) O(m * n) Medium bfs, dp, LC 542, google, microsoft again (1)(not start)
1905 Count Sub Islands Python, Java O(m * n) O(m * n) Medium bfs, dfs, amazon AGAIN (1)
2115 Find All Possible Recipes from Given Supplies Java O(n + e) O(n + e) Medium bfs, dfs, topological sort, google, array, hash table, string OK (2)
2684 Maximum Number of Moves in a Grid Java O(m * n) O(m * n) Medium bfs, top-down dp, bottom-up dp, LC weekly 345, array, matrix again (1)
2812 Find the Safest Path in a Grid Python O(n^2 * log n) O(n^2) Medium bfs, MULTI-SOURCE BFS + MAX-MIN (WIDEST PATH) DIJKSTRA, new, google AGAIN (1)
# Title Solution Time Space Difficulty Note Status
0112 Path Sum Python, Scala, Java O(n) O(h) Easy dfs, good concept, amazon, recursion, google, fb, apple, microsoft, linkedin AGAIN** (2)
0113 Path Sum II Python, Java O(n) O(h) Medium dfs, backtrack, LC 112, good basic, amazon, fb, google, apple, microsoft, linkedin, bloomberg AGAIN************ (8)(MUST)
0199 Binary Tree Right Side View Python, Java O(n) O(h) Medium dfs, good basic, bfs, apple, amazon, fb, LC 102, google, microsoft, uber, bloomberg, neetcode150, top100liked OK*** (6)
0200 Number of Islands Python, Java O(m * n) O(m * n) Medium dfs, bfs, good basic, check # 694, 711 Number of Distinct Islands, apple, goldman sachs, google, amazon, fb, LC 305, microsoft, uber, linkedin, bloomberg, blind75, top100liked OK****** (6)
0236 Lowest Common Ancestor of a Binary Tree Python, Java O(n) O(h) Medium dfs, trick, EPI, LCA, LC 1644, 235, apple, amazon, linkedin, fb, google, microsoft, uber, bloomberg, top100liked AGAIN************* (9)
0247 Strobogrammatic Number II Python, Java O(n^2 * 5^(n/2)) O(n) Medium dfs, 🔒, check #246 Strobogrammatic Number, good trick, google, fb, array, string, recursion, uber AGAIN******** (5)
0257 Binary Tree Paths Python, Java O(n * h) O(h) Easy dfs, good basic, apple, google, amazon, fb, top down, bottom up, LC 112, 113, microsoft AGAIN************ (MUST) (7)
0332 Reconstruct Itinerary Python, Java O(E * logE) O(E) Hard dfs, Hierholzer algo, yelp, google, amazon, fb, apple, microsoft, uber, bloomberg, neetcode150 AGAIN* (3) (not start)
0339 Nested List Weight Sum Python, Java O(n) O(h) Easy dfs, 🔒, good basic, bfs, linkedin, fb, amazon, microsoft, uber AGAIN*** (3)
0364 Nested List Weight Sum II Python, Java O(n) O(h) Medium dfs, 🔒, linkedin, fb AGAIN*
0366 Find Leaves of Binary Tree Python, Java O(n) O(h) Medium dfs, 🔒, linkedin, google, amazon, apple AGAIN*
0399 Evaluate Division Python, Java O(q * (V + E)) O(V + E) Medium dfs, union find, good trick, union find google, fb, google, amazon, apple, microsoft, uber, bloomberg, neetcode250 AGAIN************** (9)(MUST)
0417 Pacific Atlantic Water Flow Python, Java O(m * n) O(m * n) Medium dfs, 2 direction dfs, matrix, microsoft, google, amazon, fb, apple, uber, blind75 AGAIN** (3)
0464 Can I Win Python, Java O(n * 2^n) O(2^n) Medium dfs, DP, linkedin, math, bit manipulation, google, amazon AGAIN* (not start)
0491 Increasing Subsequences Python, Java O(n * 2^n) O(n * 2^n) Medium dfs, trick, dfs good trick, dp, yahoo, fb, array, hash table, backtracking, google, apple AGAIN***** (2)
0515 Find Largest Value in Each Tree Row Python, Java O(n) O(h) Medium dfs, good basic, linkedin, google, amazon, fb, apple, microsoft AGAIN* (3)
0529 Minesweeper Python, Java O(m * n) O(m * n) Medium dfs, bfs, recursive update, amazon, google, fb, apple, microsoft, uber, bloomberg AGAIN******** (6)
0547 Friend Circles Python, Java O(n^2) O(n) Medium dfs, graph, Union Find, bfs, check # 733 Flood Fill, bloomberg, fb, google, amazon, apple, microsoft, uber, linkedin AGAIN*** (3) (not start)
0547 Number of Provinces Python, Java O(n^2) O(n) Medium dfs, bfs, graph, union find, good basic, apple, amazon, google, fb, microsoft, uber, linkedin AGAIN************ (2) (MUST)
0582 Kill Process Python, Java O(n) O(n) Medium dfs, 🔒, BFS, good basic, google, amazon, microsoft, bloomberg AGAIN*********** (5) (MUST)
0638 Shopping Offers Python, Java O(n * 2^n) O(n) Medium dfs, google, array, dp, backtracking, amazon, fb, apple AGAIN (not start*)
0690 Employee Importance Python, Java O(n) O(h) Easy dfs, BFS, good basic, uber, google, amazon OK** (3)
0694 Number of Distinct Islands Python, Java O(m * n) O(m * n) Medium dfs, LC200, LC711, path signature, good pattern, 🔒, amazon, google, fb, apple, microsoft, uber, linkedin AGAIN************* (7) (MUST)
0695 Max Area of Island Python, Java O(m * n) O(m * n) Medium dfs, primitives in java, amazon, microsoft, linkedin, basic, google, fb, apple, bloomberg, neetcode150 AGAIN* (3)
0711 Number of Distinct Islands II Python, Java O(m * n * logn) O(m * n) Hard dfs, complex, check # 200, 694 Number of Distinct Islands, amazon OK*** (3)
0721 Accounts Merge Python , Java O(nlogn) O(n) Medium dfs, Disjoint Set Union (DSU), Union Find, path compression, complex, fb, google, amazon, microsoft, apple, twitter, uber, linkedin, neetcode250 AGAIN******* (4) (not start)
0733 Flood Fill Python, Java O(m * n) O(m * n) Easy dfs, fb, amazon, good basic, google, apple, microsoft, uber, bloomberg OK**** (5)
0737 Sentence Similarity II Python, Java O(n + p) O(p) Medium dfs, good basic, map, union find, dis-joint, google, amazon AGAIN************* (4)(MUST)
0756 Pyramid Transition Matrix Python, Java O(a^b) O(a^b) Medium dfs, dfs over the allowed triples with memo, hashmap of (a, b) -> tops, string, backtracking, google, amazon AGAIN (3) (not start)
0785 Is Graph Bipartite? Python, Java O(V + E) O(V) Medium dfs, LC 886, color, graph, bfs, fb, amazon, google, apple, microsoft, linkedin AGAIN******************* (8)
0797 All Paths From Source to Target Python, Java O(n * 2^n) O(n * 2^n) Medium dfs, graph, dfs classics, good basic, google, amazon, fb, apple, microsoft, bloomberg AGAIN** (3)
0802 Find Eventual Safe States Python, Java O(V + E) O(V) Medium dfs, Topological Sort, graph, google, amazon AGAIN********** (5)
0827 Making A Large Island Java O(m * n) O(m * n) Hard dfs, union find(DSU), 2 pass DFS/BFS, complex, google, amazon, fb, apple, uber AGAIN**** (1)
0841 Keys and Rooms Python, Java O(n + e) O(n) Medium dfs, google, bfs, good basic, amazon AGAIN*** (3)
0851 Loud and Rich Python, Java O(n + e) O(n + e) Medium dfs, amazon, defaultdict, good basic AGAIN*** (3)
0987 Vertical Order Traversal of a Binary Tree Java O(nlogn) O(n) Hard dfs, LC 314, bfs, tree map, google, amazon, fb, apple, microsoft, uber, linkedin, bloomberg AGAIN (not start)
0988 Smallest String Starting From Leaf Java O(n * h) O(h) Medium dfs, bfs, google, apple AGAIN (not start)
0990 Satisfiability of Equality Equations Python, Java O(n * a(n)) O(1) Medium dfs, union find, array, string, google, amazon AGAIN (not start)
1020 Number of Enclaves Java O(m * n) O(m * n) Medium dfs, flood fill from the border then count what remains, LC 1254, good basic, google AGAIN (1)
1087 Brace Explansion Python, Java O(n * p) O(n * p) Medium dfs, bfs, prefix sum, backtrack, good trick, Cartesian product, google, string, stack, amazon AGAIN************** (3)(MUST)
1192 Critical Connections in a Network Python, Java O(n + e) O(n + e) Hard dfs, Tarjan’s algorithm, graph, fb, amazon, google, apple AGAIN** (1) (not start)
1254 Number of Closed Islands Java O(m * n) O(m * n) Medium dfs, bfs, flood, good trick, 2 pass approach, google, amazon, fb, apple, uber AGAIN********** (1)
1376 Time Needed to Inform All Employees Python O(n) O(n) Medium dfs, invert manager to children first, answer = slowest root-to-leaf path, iterative (n = 10^5), tree, google, amazon AGAIN(1)
1466 Reorder Routes to Make All Paths Lead to the City Zero Java O(n) O(n) Medium dfs, bfs, google, amazon AGAIN (1)
1644 Lowest Common Ancestor of a Binary Tree II Python, Java O(n) O(h) Medium dfs, LCA, LC 236, microsoft, fb, google, amazon AGAIN (not start)
1650 Lowest Common Ancestor of a Binary Tree III Python, Java O(h) O(h) Medium dfs, parent node, good trick, set, dict, LCA, LC 236, amazon, google, spotify m$, fb, two pointers, tree, apple, microsoft AGAIN******** (2) (MUST)
1676 Lowest Common Ancestor of a Binary Tree IV Python, Java O(n) O(h) Medium dfs, multi node LCA, LC 236, set, m$, amazon, microsoft AGAIN********* (1) (MUST)
2049 Count Nodes With the Highest Score Python, Java O(n) O(n) Medium dfs, trick, graph, tree, google AGAIN**** (not start)
2316 Count Unreachable Pairs of Nodes in an Undirected Graph Python, Java O(n + e) O(n + e) Medium dfs, bfs, union find, good trick AGAIN******** (1)
2658 Maximum Number of Fish in a Grid Java O(m * n) O(m * n) Medium dfs, bfs, weekly_103 AGAIN (1)
2685 Count the Number of Complete Components Java O(n + e) O(n + e) Medium dfs, good trick, bfs, union find, LC weekly 345 AGAIN*** (2)
2872 Maximum Number of K-Divisible Components Java O(n) O(n) Hard dfs, BFS, topological sort, good trick, post order AGAIN*** (2)
3319 K-th Largest Perfect Subtree Size in Binary Tree Java O(nlogn) O(n) Medium dfs, good trick, binary-tree, post order AGAIN*** (2)
3965 Finish Time of Tasks I Python, Java O(n) O(n) Medium dfs, max_small_val, LC bi-weekly AGAIN******** (4)(MUST)
3997 Count Dominant Nodes in a Binary Tree Python, Java O(n) O(h) Medium dfs, LC weekly AGAIN*** (1)
4015 Weighted Sum of a Tree Python, Java O(n) O(n) Medium dfs, LC weekly AGAIN*** (1)

Backtracking

# Title Solution Time Space Difficulty Note Status
0017 Letter Combinations of a Phone Number Python, Java O(n * 4^n) O(n) Medium backtracking, dfs, good trick, uber, amazon, google, fb, apple, microsoft, bloomberg, neetcode150, top100liked AGAIN************* (11) (MUST)
0022 Generate Parentheses Python, Java O(4^n / n^(3/2)) O(n) Medium backtracking, LC 20, good basic, stack, backtrac, Divide and Conquer, amazon, google, fb, apple, microsoft, uber, bloomberg, neetcode150, top100liked OK**************** (5) (but again, MUST)
0037 Sudoku Solver Python, Java O(9^m) O(m) Hard backtracking, backtrack over the m empty cells, row/col/box bitsets, google, amazon, uber, fb, apple, microsoft AGAIN(not start)
0039 Combination Sum Python, Java O(k * n^k) O(k) Medium backtracking, dfs, good basic, uber, airbnb, amazon, fb, google, apple, microsoft, linkedin, bloomberg, blind75, top100liked OK********* (7) (but again)
0040 Combination Sum II Python, Java O(k * C(n, k)) O(k) Medium backtracking, LC 39, avoud duplicated, amazon, fb, apple, microsoft, uber, linkedin, neetcode150 AGAIN******* (4) (MUST)
0046 Permutations Python, Java O(n * n!) O(n) Medium backtracking, LC #77, 78, good concept, microsoft, linkedin, amazon, fb, google, apple, uber, bloomberg, neetcode150, top100liked OK*********** (4) (AGAIN, MUST)
0047 Permutations II Python, Java O(n * n!) O(n) Medium backtracking, LC 46, avoid same layer duplicated, apple, amazon, microsoft, fb, uber, linkedin, neetcode250 AGAIN***** (MUST)
0051 N-Queens Python, Java O(n!) O(n^2) Hard backtracking, matrix, bitmask, google, amazon, fb, apple, microsoft, uber, neetcode150, top100liked AGAIN********* (2)(MUST)
0052 N-Queens II Python, Java O(n!) O(n) Hard backtracking, matrix, amazon, neetcode250 AGAIN
0077 Combinations Python, Java O(k * C(n, k)) O(k) Medium backtracking, good trick, google, amazon, fb, apple, microsoft, neetcode250 OK************* (5) (but again, MUST)
0078 Subsets Python, Java O(n * 2^n) O(n) Medium backtracking, good concept, similar as, dfs, #90 Subsets II , uber, amazon, fb, google, apple, microsoft, bloomberg, neetcode150, top100liked AGAIN**************** (7) (MUST again!!!)
0079 Word Search Python, Java O(m * n * 4^l) O(l) Medium backtracking, card, LC 212, good trick, dfs, bloomberg, microsoft, amazon, fb, google, apple, uber, linkedin, blind75, top100liked AGAIN*************** (10) (MUST)
0090 Subsets II Python, Java O(n * 2^n) O(n) Medium backtracking, good basic, check # 078 Subsets, dfs, fb, google, amazon, apple, microsoft, uber, neetcode150 AGAIN********* (6)
0093 Restore IP Addresses Python, Java O(1) O(1) Medium backtracking, good trick, recursive, IP address, amazon, google, fb, apple, microsoft AGAIN****** (4)
0131 Palindrome Partitioning Python, Java O(n * 2^n) O(n^2) Medium backtracking, dfs, good trick, amazon, google, fb, apple, microsoft, uber,neetcode150, top100liked AGAIN************** (9) (MUST)
0139 Word Break Python, Java O(n^2 * l) O(n) Medium backtracking, card, dfs, dp, good DP basic, uber, yahoo, amazon, google, fb, array, hash table, string, apple, microsoft, bloomberg, blind75, top100liked AGAIN********************** (9) (MUST)
0140 Word Break II Python, Java O(n * 2^n) O(n * 2^n) Hard backtracking, good basic, LC 078, dfs, dp, trick, amazon, google, fb, apple, microsoft, uber, bloomberg, neetcode250 AGAIN******** (2)
0212 Word Search II Python, Java O(m * n * 4^l) O(t) Hard backtracking, LC 208, LC 079, hashset, hashmap, trie, backtrack with trie, amazon, fb, apple, twitter, uber, google, indeed, microsoft, blind75 AGAIN********** (3)
0216 Combination Sum III Python, Java O(k * C(n, k)) O(k) Medium backtracking, LC 39, LC 40, pick k distinct numbers from 1…9, google, amazon, microsoft AGAIN*
0254 Factor Combinations Python, Java O(sqrt(n) * f) O(logn) Medium backtracking, 🔒, f = number of factor combinations, dfs from the smallest factor, google, uber, linkedin AGAIN (not start)
0267 Palindrome Permutation II Python, Java O(n * n!) O(n) Medium backtracking, 🔒, LC 266, permute half then mirror, google, amazon, fb, uber AGAIN (not start*)
0282 Expression Add Operators Python O(4^n * n) O(n) Hard backtracking, carry the last operand so * can be undone, leading-zero guard, complex, google, amazon, fb, apple, microsoft, uber, linkedin AGAIN(1)
0294 Flip Game II Python, Java O(n * 2^n) O(2^n) Medium backtracking, 🔒, DP, Hash, google AGAIN*
0301 Remove Invalid Parentheses Python O(2^n * n) O(2^n * n) Hard backtracking, BFS level by level = minimum removals, LC 20, LC 921, dedupe the frontier, good trick, google, amazon, fb, apple, uber, bloomberg AGAIN(1)
0320 Generalized Abbreviation Python, Java O(n * 2^n) O(n) Medium backtracking, 🔒, abbreviate or keep each char, bit mask, dfs, google AGAIN (not start*)
0425 Word Squares Python O(m * 26^L * L) O(m * L) Hard backtracking, prefix map, row k is forced by column k, LC 212, trie, good trick, google AGAIN(1)
0489 Robot Room Cleaner Python, Java O(m * n) O(m * n) Hard backtracking, 🔒, google, amazon, fb, microsoft AGAIN (not start)
0526 Beautiful Arrangement Python, Java O(n!) O(n) Medium backtracking, backtrack with divisibility pruning, bitmask dp, good trick, google, amazon AGAIN (not start*)
0676 Implement Magic Dictionary Python, Java build: O(t), search: O(26 * l) O(t) Medium backtracking, Trie, DFS, hash table, string, google, amazon, fb, microsoft AGAIN (not start)
0698 Partition to K Equal Sum Subsets Python, Java O(n * 2^n) O(2^n) Medium backtracking, DP, Memoization, similar as #416 Partition Equal Subset Sum, #473 Matchsticks to Square, google, amazon, fb, apple, microsoft, linkedin, neetcode250 AGAIN****** (2) (MUST)
0718 Maximum Length of Repeated Subarray Python, Java O(m * n) O(min(m, n)) Medium backtracking, DP, Hash, Binary Search, array, google, amazon, apple AGAIN (not start*)
0784 Letter Case Permutation Python, Java O(n * 2^n) O(n) Medium backtracking, dfs, recursion, good trick, fb, amazon, apple, microsoft AGAIN****** (3)
0980 Unique Paths III Python, Java O(3^(m * n)) O(m * n) Hard backtracking, good trick, LC 62, 63, dfs, amazon, google, fb, apple, microsoft AGAIN********** (3)
1219 Path with Maximum Gold Python, Java O(3^(m * n)) O(m * n) Medium backtracking, dfs, bfs, google, amazon, apple AGAIN**** (1)

Dynamic Programming

# Title Solution Time Space Difficulty Note Status
0044 Wildcard Matching Python O(m * n) O(m * n) Hard dp, 2D dp, wildcard, greedy two-pointer, amazon, facebook, google AGAIN (1)
0053 Maximum Subarray Python, Java O(n) O(1) Medium dp, card, MUST, brute force, Kadane algo, pre-sum array, dp basic, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN**************** (8)
0062 Unique Paths Python, Java O(m * n) O(n) Medium dp, 2D dp, basic, fb, google, apple, amazon, microsoft, uber, bloomberg, blind75, top100liked AGAIN********* (3)(MUST)
0063 Unique Paths II Python, Java O(m * n) O(n) Medium dp, trick, LC 64, dfs + dp, amazon, google, fb, apple, microsoft, bloomberg, neetcode250 AGAIN*
0064 Minimum Path Sum Python, Java O(m * n) O(n) Medium dp, Sum of grid values, Dijkstra, LC 1631, amazon, google, fb, apple, microsoft, uber, neetcode250, top100liked AGAIN******* (3)(MUST)
0070 Climbing Stairs Python, Java O(n) O(1) Easy dp, Matrix Exponentiation, recursion, apple, google, amazon, fb, microsoft, uber, bloomberg, blind75, top100liked OK* (2)
0072 Edit Distance Python, Java O(m * n) O(m * n) Medium dp, 2D DP, dp state, apple, google, amazon, fb, microsoft, uber, linkedin, bloomberg, neetcode150, top100liked AGAIN************ (5) (MUST)
0091 Decode Ways Python, Java O(n) O(1) Medium dp, card, good basic, microsoft, uber, amazon, fb, google, apple, bloomberg, blind75 AGAIN*********************** (6) (MUST)
0096 Unique Binary Search Trees Python, Java O(n^2) O(n) Medium dp, Math, fb, amazon, google, apple, microsoft, bloomberg AGAIN* (2) (not start)
0097 Interleaving String Java, Python O(m * n) O(n) Medium dp, card, 1D, 2D DP, state machine, good trick, google, amazon, apple, microsoft, uber, bloomberg, neetcode150 again************ (4)(MUST)
0115 Distinct Subsequences Java O(m * n) O(n) Hard dp, 2D dp, good trick, needcode 150, google, amazon, apple, neetcode150 AGAIN******** (1)
0120 Triangle Python, Java O(m * n) O(n) Medium dp, amazon, google, apple, microsoft, bloomberg AGAIN* (not start) (2)
0123 Best Time to Buy and Sell Stock III Python, Java O(n) O(1) Hard dp, amazon, uber, apple, google, fb, microsoft AGAIN* (not start) (1)
0132 Palindrome Partitioning II Python O(n^2) O(n^2) Hard dp, LC 131, palindrome table + min-cut per prefix in one pass, 2D dp, good trick, google, amazon AGAIN(1)
0152 Maximum Product Subarray Python, Java O(n) O(1) Medium dp, Kadane algo, brute force, google, amazon, linkedin, fb, apple, microsoft, uber, blind75, top100liked AGAIN***** (1)
0198 House Robber Python, Java O(n) O(1) Easy dp, dp basic, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN*** (2)
0213 House Robber II Python, Java O(n) O(1) Medium dp, card, good trick, LC 198, circular dp, google, amazon, apple, microsoft, blind75 AGAIN*************** (4)(MUST)
0221 Maximal Square Python, Java O(m * n) O(n) Medium dp, EPI, amazon, fb, google, apple, microsoft, uber, bloomberg AGAIN** (3) (not start)
0256 Paint House Python, Java O(n) O(1) Medium dp, google, 🔒, amazon, apple, linkedin AGAIN (2)
0276 Paint Fence Python, Java O(n) O(1) Easy dp, good basic, 2 state DP, 🔒, google AGAIN*********(3)
0279 Perfect Squares Python, Java O(n * sqrt(n)) O(n) Medium dp, bfs, 0/1 nbounded knapsack, GOOD trick, google, amazon, fb, apple, microsoft, uber, neetcode250, top100liked AGAIN************ (3)(MUST)
0303 Range Sum Query - Immutable Python, Java ctor: O(n), lookup: O(1) O(n) Easy dp, prefix sum, LC 304, good basic, array, design, google, amazon, fb, bloomberg OK
0304 Range Sum Query 2D - Immutable Python, Java ctor: O(m * n), lookup: O(1) O(m * n) Medium dp, prefix sum, NOTE: idx, trick, fb, array, design, matrix, google, amazon, apple, microsoft, neetcode250 AGAIN******** (6)
0309 Best Time to Buy and Sell Stock with Cooldown Python, Java O(n) O(1) Medium dp, 2D dp, n x m array, good basic, google, amazon, fb, apple, neetcode150 AGAIN********* (1)(MUST)
0312 Burst Balloons Java O(n^3) O(n^2) Hard dp, interval dp, think in reverse (which balloon bursts last), good trick, google, amazon, fb, apple, microsoft, uber, neetcode150 AGAIN (not start)
0322 Coin Change Python, Java O(n * k) O(k) Medium dp, card, bfs, dfs, grab, google, fb, apple, amazon, microsoft, uber, linkedin, bloomberg, blind75, top100liked AGAIN****************** (7) (MUST)
0329 Longest Increasing Path in a Matrix Java O(m * n) O(m * n) Hard dp, good trick, dfs+dp, 2D DP, topo sort, google, amazon, fb, apple, microsoft, uber, neetcode150 AGAIN************* (3)(MUST)
0351 Android Unlock Patterns Python, Java O(9^2 * 2^9) O(9 * 2^9) Medium dp, 🔒 Backtracking, google, apple AGAIN (not start)
0357 Count Numbers with Unique Digits Python, Java O(n) O(1) Medium dp, Backtracking, Math, google AGAIN (not start)
0361 Bomb Enemy Python, Java O(m * n) O(m * n) Medium dp, 🔒, google, amazon, uber AGAIN* (2)
0363 Max Sum of Rectangle No Larger Than K Python, Java O(m^2 * nlogn) O(n) Medium dp, pre-sum. google, array, binary search, matrix, google, apple, microsoft AGAIN* (not start)
0368 Largest Divisible Subset Python, Java O(n^2) O(n) Medium dp, sort then LIS-style dp, backtrack the chain, good trick, google, amazon, fb, apple, microsoft AGAIN (not start)
0375 Guess Number Higher or Lower II Python, Java O(n^3) O(n^2) Medium dp, interval dp / minimax, pick the cost that minimizes the worst case, good trick, google AGAIN (not start)
0377 Combination Sum IV Python, Java O(n * t) O(t) Medium dp, LC 518, dp basic, fb, google, amazon, apple, neetcode250 AGAIN******** (3)
0403 Frog Jump Python, Java O(n^2) O(n^2) Hard dp, dfs, bfs, Memoization dfs, amazon, microsoft, google, fb, apple AGAIN (not start)
0416 Partition Equal Subset Sum Python, Java O(n * s) O(s) Medium dp, card, good basic, 0/1 knapsack, backward, 1d, 2d dp, fb, google, apple, amazon, microsoft, uber, neetcode150, top100liked AGAIN******************* (6) (MUST)
0418 Sentence Screen Fitting Python, Java O(r + n * c) O(n) Medium dp, 🔒, google, uber AGAIN (not start)
0467 Unique Substrings in Wraparound String Python, Java O(n) O(1) Medium dp, longest consecutive substring ending at each letter, good trick, apple AGAIN (not start)
0471 Encode String with Shortest Length Python, Java O(n^3) on average O(n^2) Medium dp, 🔒, google, amazon, microsoft AGAIN (not start)
0472 Concatenated Words Python, Java O(n * l^2) O(n * l) Hard dp, good trick, trie+dfs, dfs, amazon, fb, apple, microsoft AGAIN******** (3)
0474 Ones and Zeroes Python, Java O(s * m * n) O(m * n) Medium dp, good basic, 2D 0/1 knapsack, google, amazon AGAIN***** (2) (not start)
0486 Predict the Winner Python, Java O(n^2) O(n) Medium dp, good trick, 1d, 2d DP, google, amazon, uber AGAIN********* (again)(MUST)
0494 Target Sum Python, Java O(n * s) O(s) Medium dp, 2D dp, math, fb, google, amazon, apple, microsoft, uber, neetcode150 AGAIN****** (1)
0509 Fibonacci Number Python, Java O(logn) O(1) Easy dp, variant of Climbing Stairs, Matrix Exponentiation, Spotify, google, amazon, fb, apple, microsoft OK**
0516 Longest Palindromic Subsequence Python, Java O(n^2) O(n) Medium dp, good basic, 2D DP, backward+forward, forward+forward, uber, amazon, google, fb, apple, microsoft, linkedin AGAIN**************** (MUST)
0518 Coin Change 2 Python, Java O(n * amount) O(amount) Medium dp, dp basic, good trick, LC 322, 377, google, fb, amazon, apple, microsoft, uber, neetcode150 AGAIN******** (4)
0552 Student Attendance Record II Java O(n) O(1) Medium dp, 2d, 3d dp, good trick, google, uber AGAIN*********** (3)
0562 Longest Line of Consecutive One in Matrix Python, Java O(m * n) O(n) Medium dp, 🔒, google AGAIN (not start)
0576 Out of Boundary Paths Python, Java O(N * m * n) O(m * n) Medium dp, bfs, amazon AGAIN (not start)
0583 Delete Operation for Two Strings Python, Java O(m * n) O(n) Medium dp, google AGAIN (not start)
0639 Decode Ways 2 Java O(n) O(1) Hard dp, LC 91, state dp with the * wildcard, mod 1e9+7, google, amazon, fb, microsoft AGAIN (1) (not start)
0650 2 Keys Keyboard Python, Java O(sqrt(n)) O(1) Medium dp, dp basic, microsoft, google, amazon AGAIN*
0673 Number of Longest Increasing Subsequence Python, Java O(n^2) O(n) Medium dp, good trick, fb, google, amazon AGAIN********** (3)
0688 Knight Probability in Chessboard Python, Java O(k * n^2) O(n^2) Medium dp, dp basic, AGAIN, microsoft, goldman sachs, google, fb, amazon, apple AGAIN********* (5)
0712 Minimum ASCII Delete Sum for Two Strings Python, Java O(m * n) O(n) Medium dp, LC 583, 2D dp on ASCII sums AGAIN (not start)
0714 Best Time to Buy and Sell Stock with Transaction Fee Python, Java O(n) O(1) Medium dp, AGAIN, good basic, greedy, fb, google, amazon, bloomberg AGAIN******** (3)
0727 Minimum Window Subsequence Java O(m * n) O(m * n) Hard dp, google, amazon, fb, apple, bloomberg AGAIN (not start)
0740 Delete and Earn Python, Java O(n + k) O(k) Medium dp, LC 198, google, amazon, fb, apple, microsoft, uber AGAIN********* (1)(MUST)
0746 Min Cost Climbing Stairs Python, Java O(n) O(1) Easy dp, good dp basic, amazon, google, apple, microsoft, uber, neetcode150 AGAIN**** (2)
0750 Number Of Corner Rectangles Python, Java O(n * m^2) O(n * m) Medium dp, fb, google AGAIN (3) (not start)
0764 Largest Plus Sign Python, Java O(n^2) O(n^2) Medium dp, complex, fb, google, uber AGAIN (not start) (2)
0788 Rotated Digits Python, Java O(logn) O(logn) Easy dp, Brute Force, Memoization, google, amazon, fb OK*
0790 Domino and Tromino Tiling Python, Java O(logn) O(1) Medium dp, Matrix Exponentiation, google, amazon AGAIN (not start)
0799 Champagne Tower Python, Java O(n^2) O(n) Medium dp, simulate the poured volume flowing down each row, 2D dp, google AGAIN
0801 Minimum Swaps To Make Sequences Increasing Python, Java O(n) O(1) Medium dp, amazon, fb, google, apple AGAIN***** (not start) (2)
0808 Soup Servings Python, Java O(1) O(1) Medium dp, memoized probability dp, converges to 1 for large n, trick, google AGAIN (not start)
0813 Largest Sum of Averages Python, Java O(k * n^2) O(n) Medium dp, google, amazon, apple AGAIN (not start)
0823 Binary Trees With Factors Python, Java O(n^2) O(n) Medium dp, sort + hashmap dp, count trees keyed by root value, amazon AGAIN (not start)
0837 New 21 Game Python, Java O(n) O(n) Medium dp, trick, math, google, apple, uber AGAIN (2) (not start)
0838 Push Dominoes Python, Java O(n) O(n) Medium dp, two pointers, google, amazon AGAIN (not start)
0871 Minimum Number of Refueling Stops Java O(nlogn) O(n) Hard dp, PQ, good trick, google, amazon, apple, microsoft, uber AGAIN***** (1)
0877 Stone Game Python, Java O(n^2) O(n) Medium dp, LC 486, math, game theory, variant of Predict the Winner, google, amazon, apple, neetcode250 AGAIN*** (1)
0926 Flip String to Monotone Increasing Python, Java O(n) O(1) Medium dp, card, good trick, prefix idx VS str idx, prefix sum, google, amazon AGAIN*************** (6)(MUST)
0931 Minimum Falling Path Sum Python, Java O(n^2) O(1) Medium dp, google, good basic, amazon, apple AGAIN******** (2)(MUST)
0935 Knight Dialer Python, Java O(logn) O(1) Medium dp, Matrix Exponentiation, google, microsoft, fb, amazon, apple AGAIN (not start)
0983 Minimum Cost For Tickets Java O(n) O(n) Medium dp, google, amazon, fb, apple, uber AGAIN (not start)
1000 Minimum Cost to Merge Stones Python, Java O(n^3 / k) O(n^2) Hard dp, amazon, google AGAIN (not start)
1025 Divisor Game Java O(1) O(1) Easy dp, n % 2 == 0 wins, math, good trick, google, amazon, uber AGAIN (not start)
1048 Longest String Chain Java O(n * l^2) O(n) Medium dp, 1D dp, hashmap, string, good basic, google, amazon, fb, microsoft AGAIN******** (1)(MUST)
1049 Last Stone Weight II Python, Java O(n * s) O(s) Medium dp, good trick !!!, 0/1 knapsack, minimize abs(S1 - S2), LC 416, 494, google, amazon, neetcode250 AGAIN****** (1)
1137 N-th Tribonacci Number Python, Java O(n) O(1) Easy dp, good basic, amazon, fb, neetcode250 AGAIN**
1140 Stone Game II Java O(n^3) O(n^2) Medium dp, need_code_250, google, neetcode250 AGAIN**
1143 Longest Common Subsequence Python, Java O(m * n) O(n) Medium dp, card, Memoization, 2D dp, amazon, karat, google, fb, microsoft, uber, blind75, top100liked AGAIN******************** (6)(DP MUST)
1218 Longest Arithmetic Subsequence of Given Difference Python O(n) O(n) Medium dp, HASH MAP DP, google, fb, uber AGAIN******** (2) (MUST)
1277 Count Square Submatrices with All Ones Java O(m * n) O(1) Medium dp, google, amazon, fb, microsoft AGAIN(1) (not start)
1312 Minimum Insertion Steps to Make a String Palindrome Python, Java O(n^2) O(n) Hard dp, amazon, google, apple, microsoft AGAIN (not start)
1335 Minimum Difficulty of a Job Schedule Python, Java O(d * n^2) O(d * n) Hard dp, amazon, google, uber not start
1406 Stone Game III Java O(n) O(n) Medium dp, amazon, google, neetcode250 AGAIN (not start)
1617 Count Subtrees With Max Distance Between Cities Java O(n^2 * 2^n) O(n^2) Hard dp, enumerate subsets with a bitmask, tree diameter per subset, complex AGAIN (not start)
1799 Maximize Score After N Operations Python, Java O(n^2 * 2^n) O(2^n) Medium dp, amazon not start
2560 House Robber IV Java O(nlog(max)) O(1) Medium dp, binary search AGAIN (not start)
2646 Minimize the Total Price of the Trips Java O(m * n) O(n) Hard dp, dfs, LC weekly AGAIN (1) (not start)
2765 Longest Alternating Subarray Java O(n) O(1) Easy dp, 2 pointers, good trick, array AGAIN***** (1)
2767 Partition String Into Minimum Beautiful Substrings Java O(n^2) O(n) Medium dp, dp over prefixes, powers of 5 written in binary AGAIN(1)
3122 Minimum Number of Operations to Satisfy Conditions Java O(m * n + n * 100) O(n * 10) Medium dp, LC weekly, PQ Again (1)
3196 Maximize Total Cost of Alternating Subarrays Java O(n) O(1) Medium dp, LC weekly Again

Greedy

# Title Solution Time Space Difficulty Note Status
0011 Container With Most Water Python, Java O(n) O(1) Medium greedy, good basics, two pointers, fb, amazon, google, apple, microsoft, uber, bloomberg, blind75, top100liked OK*** (3) (but again !!)
0045 Jump Game II Python, Java O(n) O(1) Medium greedy, google, apple, fb, tesla, amazon, microsoft, uber, neetcode150, top100liked AGAIN******** (4) (MUST)
0055 Jump Game Python, Java O(n) O(1) Medium greedy, good trick, backtrack, DP, amazon, google, fb, apple, microsoft, uber, blind75, top100liked AGAIN*********** (9)(MUST)
0084 Largest Rectangle in Histogram Python, Java O(n) O(n) Hard greedy, brute force, good trick, mono stack, LC 085, amazon, fb, array, google, apple, microsoft, uber, bloomberg, neetcode150, top100liked AGAIN******** (3)
0122 Best Time to Buy and Sell Stock II Python, Java O(n) O(1) Easy greedy, compare with #309 Best Time to Buy and Sell Stock with Cooldown , #714 Best Time to Buy and Sell Stock with Transaction Fee, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, neetcode250 again* (2)
0134 Gas Station Python, Java O(n) O(1) Medium greedy, trick, amazon, google, fb, apple, microsoft, uber, neetcode150 AGAIN****** (5)
0135 Candy Python, Java O(n) O(n) Hard greedy, LC 123, boundary, array, amazon, google, apple, microsoft, neetcode250 AGAIN (2)
0218 The Skyline Problem Python, Java O(nlogn) O(n) Hard greedy, brute force, swipe line, Priority Queue, Union Find, Divide-and-Conquer, apple, microsoft, array, binary indexed tree, google, amazon, fb, uber AGAIN (not start)
0316 Remove Duplicate Letters Python, Java O(n) O(1) Medium greedy, good trick, MONO stack, char, visited, LC 1081, google, amazon, fb, apple, microsoft AGAIN********* (4)(MUST)
0319 Bulb Switcher Python, Java O(1) O(1) Medium greedy, duplicate of the Math entry, answer is floor(sqrt(n)), good trick, fb, apple, microsoft not start
0330 Patching Array Python, Java O(n) O(1) Hard greedy, array, amazon, google, uber AGAIN (not start)
0358 Rearrange String k Distance Apart Python, Java O(n) O(k) Hard greedy, PQ, check LC 767, cooldown queue, good trick, google, amazon, fb AGAIN*** (1)
0376 Wiggle Subsequence Python, Java O(n) O(1) Medium greedy, count direction changes, greedy or dp, good basic, amazon, apple, uber AGAIN*
0392 Is Subsequence Python, Java O(n) O(1) Easy greedy, basics, 2 pointers, dp, string, google, amazon, fb, uber AGAIN********* (1)(MUST)
0397 Integer Replacement Python, Java O(logn) O(1) Medium greedy, Recursion basics, Math, google, amazon, microsoft OK*
0402 Remove K Digits Python, Java O(n) O(n) Medium greedy, card, LintCode, mono stack, str, good trick, google, amazon, fb, microsoft AGAIN************* (4)(MUST)
0435 Non-overlapping Intervals Python, Java O(nlogn) O(1) Medium greedy, card, good trick, inverval, LC 452, Line Sweep, google, amazon, fb, apple, microsoft, blind75 AGAIN**************** (10)(must)
0452 Minimum Number of Arrows to Burst Balloons Python, Java O(nlogn) O(1) Medium greedy, sort, compare i-1 element, overlap, good basic, google, amazon, fb, apple, microsoft, uber AGAIN***** (3)
0455 Assign Cookies Python, Java O(nlogn + mlogm) O(1) Easy greedy, sort both arrays then two pointers, basic, amazon, apple OK*
0621 Task Scheduler Python, Java O(n) O(1) Medium greedy, trick, PQ+queue, compare with 767, cool down, fb, amazon, google, apple, microsoft, uber, neetcode150 AGAIN********* (8)(MUST)
0646 Maximum Length of Pair Chain Python, Java O(nlogn) O(1) Medium greedy, good trick, similar as #435 Non-overlapping Intervals, Line Sweep, amazon, fb, apple, uber, bloomberg OK********** (5) (but again)
0649 Dota2 Senate Python, Java O(n) O(n) Medium greedy, complex question, neetcode250 AGAIN (not start*)
0659 Split Array into Consecutive Subsequences Python, Java O(n) O(n) Medium greedy, map, pq, dp, google, uber AGAIN***** (1)
0672 Bulb Switcher II Python, Java O(1) O(1) Medium greedy, duplicate of the Math entry, only 6 reachable states, trick, bit manipulation, dfs, microsoft not start
0738 Monotone Increasing Digits Python, Java O(logn) O(logn) Medium greedy, good trick, string, trick, amazon AGAIN********* (4)
0763 Partition Labels Python, Java O(n) O(1) Medium greedy, good trick, dict, sliding window, amazon, google, fb, apple, microsoft, uber, neetcode150, top100liked AGAIN******* (6) (AGAIN)
0765 Couples Holding Hands Java O(n) O(n) Hard greedy, hashmap, union find, google, fb AGAIN (not start)
0767 Reorganize String Python, Java O(n) O(1) Medium greedy, card, LC 1054, compare with 621, PQ, hashmap, good trick, amazon, fb, google, apple, microsoft, uber, neetcode250 AGAIN****************** (9) (MUST)
0861 Score After Flipping Matrix Python, Java O(r * c) O(1) Medium greedy, greedy: make column 0 all ones, then maximize each column, good trick, amazon AGAIN (not start*)
0870 Advantage Shuffle Python, Java O(nlogn) O(n) Medium greedy, sort both then greedily assign the smallest winning card (Tian Ji horse racing), good trick, fb, apple OK*
0881 Boats to Save People Python, Java O(nlogn) O(n) Medium greedy, good trick, google, amazon, neetcode250 AGAIN* (2)
0948 Bag of Tokens Python, Java O(nlogn) O(1) Medium greedy, Two Pointers, google AGAIN*** (1) (not start)
0962 Maximum Width Ramp Python, Java O(n) O(n) Medium greedy, Descending Stack, array, two pointers, google, fb, apple AGAIN (not start)
0978 Longest Turbulent Subarray Java O(n) O(1) Medium greedy, sliding window, array, dp, amazon, bloomberg, neetcode250 AGAIN (not start)
0984 String Without AAA or BBB Java, Python O(n) O(n) Medium greedy, good basic, while, string builder, endsWith, PQ, microsoft AGAIN***** (2)
1024 Video Stitching Python, Java O(nlogn) O(1) Medium greedy, Spotify, google, amazon AGAIN (not start)
1102 Path With Maximum Minimum Value Python, Java O(m * nlog(m * n)) O(m * n) Medium greedy, dfs, dp, amazon, array, binary search, google, fb not start
1249 Minimum Remove to Make Valid Parentheses Python O(n) O(n) Medium greedy, GREEDY, TWO PASSES, good basic, stack, google, amazon, fb, apple, microsoft, uber AGAIN******* (1)
1375 Bulb Switcher III Python, Java O(n) O(1) Medium greedy, queue, array, gra*, amazon, microsoft AGAIN*** (1)
1380 Lucky Numbers in a Matrix Java O(m * n) O(m + n) Easy greedy, intersect the row minimums with the column maximums, matrix, basic, array, apple AGAIN (1)
1546 Maximum Number of Non-Overlapping Subarrays With Sum Equals Target Python, Java O(n) O(n) Medium greedy, prefix + greedy, good trick, google, microsoft AGAIN*** (1)
1648 Sell Diminishing-Valued Colored Balls Python, Java O(nlogn) O(1) Medium greedy, trick, sorting, heapq, binary search, amazon AGAIN*** (2) (not start)
1710 Maximum Units on a Truck Python, Java O(nlogn) O(1) Easy greedy, sort, amazon, apple AGAIN******** (3) (MUST)
1791 Find Center of Star Graph Java O(1) O(1) Easy greedy, degree cnt, graph AGAIN (1)
1851 Minimum Interval to Include Each Query Java O(nlogn + qlogq) O(n + q) Hard greedy, needcode 150, PQ, interval, sort, scan line, Segment Tree, google, array, binary search, neetcode150 AGAIN************** (1)
1871 Jump Game VII Java O(n) O(n) Medium greedy, bfs, string, dp, sliding window, google, amazon, neetcode250 AGAIN (not start)
1899 Merge Triplets to Form Target Triplet Java O(n) O(1) Medium greedy, sort, amazon, google, neetcode150 AGAIN(1) (not srart)
2126 Destroying Asteroids Java O(nlogn) O(1) Medium greedy, sort, google AGAIN(1) (not srart)
2279 Maximum Bags With Full Capacity of Rocks Java O(nlogn) O(n) Medium greedy, sort AGAIN (1)
2591 Distribute Money to Maximum Children Java O(1) O(1) Easy greedy, LC weekly AGAIN (1)
2643 Row With Maximum Ones Java O(m * n) O(1) Easy greedy, count ones per row, matrix, basic, array AGAIN(1) (not srart)
2645 Minimum Additions to Make Valid String Java O(n) O(1) Medium greedy, string AGAIN(1) (not srart)
2656 Maximum Sum With Exactly K Elements Java O(n) O(1) Easy greedy, weekly_103 AGAIN(1) (not srart)
2960 Count Tested Devices After Test Operations Java O(n) O(1) Easy greedy, running count of tested devices acts as the decrement, good trick, array, simulation, counting AGAIN(1) (not srart)
3120 Count the Number of Special Characters I Java O(n) O(1) Easy greedy, hashset of seen chars, require both cases, LC 3121, basic, string AGAIN(1) (not srart)
3689 Maximum Total Subarray Value I Java O(n) O(1) Medium greedy, math, brute force OK
3690 Split and Merge Array Transformation Java O(n! * n^4) O(n! * n) Medium greedy, bfs dfs, array, hash table AGAIN (not start)
3691 Maximum Total Subarray Value II Java O((n + k) * logn) O(nlogn) Hard greedy, brute force, tree AGAIN
3994 Transform Binary String Using Subsequence Sort Python, Java O(n) O(1) Medium greedy, brute force, LC weekly AGAIN*****(1)
3998 Transform Binary String Using Subsequence Sort Python, Java O(n * m) O(n) Medium greedy, brute force, prefix, LC weekly AGAIN
4040 Minimum Operations to Form Subset Sum I Python O(n * sum * logx) O(sum) Medium dp, group 0/1 knapsack, per-element (value, cost) options, x2 / x//2 chains, LC weekly AGAIN(1)

Graph

# Title Solution Time Space Difficulty Note Status
0269 Alien Dictionary Python, Java O(n * l) O(1) Hard graph, card, good trick, dfs, bfs, Topologicals sort, fb, google, microsoft, airbnb, uber, amazon, apple, bloomberg, blind75 AGAIN*************** (7)(MUST)
0305 Number of Islands II Java O(k * a(m * n)) O(m * n) Hard graph, union find, LC 200, google, amazon, fb, apple, uber AGAIN (1)
0323 Number of Connected Components in an Undirected Graph Python , Java O(n + e) O(n) Medium graph, card, LC 547, 🔒, bfs, dfs, Union Find, linkedin, amazon, fb, google, microsoft, apple, blind75 AGAIN************** (6) (MUST)
0778 Swim in Rising Water Java O(n^2 * logn) O(n^2) Medium graph, Dijkstra, google, amazon, fb, neetcode150 AGAIN (1) (not start)
0959 Regions Cut By Slashes Python, Java O(n^2 * a(n^2)) O(n^2) Medium graph, Union Find, amazon, apple, uber again
0997 Find the Town Judge Python, Java O(n + e) O(n) Easy graph, in-degree minus out-degree equals n - 1, good basic, google, amazon, apple, neetcode250 again
1135 Connecting Cities With Minimum Cost Python, Java O(e * loge) O(n) Medium graph, union find, Kruskal, prime, amazon, google, uber AGAIN (not start)
1462 Course Schedule IV Java O(n^3) O(n^2) Medium graph, Floyd-Warshall reachability, or topological sort with reach sets, LC 207, amazon, uber, neetcode250 AGAIN (not start)
1489 Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree Java O(e^2 * a(n)) O(n + e) Hard graph, dfs, bfs, Dijkstra, amazon, neetcode250 AGAIN (not start)
1514 Path with Maximum Probability Python, Java O(e * logn) O(n + e) Medium graph, Dijkstra, google AGAIN (not start)
1584 Min Cost to Connect All Points Java O(n^2 * logn) O(n^2) Medium graph, Kruskal algo, Prim algo, advanced graph, amazon, neetcode150 AGAIN (not start)
1631 Path With Minimum Effort Python, Java O(m * nlog(m * n)) O(m * n) Medium graph, Max of step differences, dfs, bfs+PQ, LC 64, Dijkstra, google, amazon, neetcode250 AGAIN********** (2)(MUST)
1761 Minimum Degree of a Connected Trio in a Graph Java O(n^3) O(n^2) Hard graph, DP, amazon AGAIN (not start)
1971 Find if Path Exists in Graph Java O(n + e) O(n + e) Easy graph, bfs, dfs, union find, google, amazon, microsoft AGAIN (1)
2290 Minimum Obstacle Removal to Reach Corner Java O(m * nlog(m * n)) O(m * n) Hard graph, bfs, PQ, Dijkstra classics AGAIN****** (2)(MUST)
2392 Build a Matrix With Conditions Java O(k^2) O(k^2) Hard graph, dfs, bfs, Dijkstra, neetcode250 AGAIN (not start)
2508 Add Edges to Make Degrees of All Nodes Even Java O(n + e) O(n + e) Hard graph, LC weekly AGAIN (not start)
2617 Minimum Number of Visited Cells in a Grid Java O(m * nlog(m * n)) O(m * n) Hard graph, PQ, stack, LC weekly AGAIN***** (1) (not start)
2642 Design Graph With Shortest Path Calculator Java ctor: O(n^3), addEdge: O(n^2), shortestPath: O(1) O(n^2) Medium graph, Dijkstra, floyd warshall, LC weekly 102 AGAIN******** (2)
2709 Greatest Common Divisor Traversal Java O(n * sqrt(maxV) * a(n)) O(n + maxV) Hard graph, union find over shared prime factors, sieve, complex, neetcode250 AGAIN (not start)
3123 Find Edges in Shortest Paths Java O(e * logn) O(n + e) Hard graph, Dijkstra from both ends, keep edges lying on some shortest path, good trick AGAIN (1) (not start)

Geometry

# Title Solution Time Space Difficulty Note Status
0587 Erect the Fence Python, Java O(nlogn) O(n) Hard geometry, complex, Convex Hull, Monotone Chain, amazon, google AGAIN (not start)
0892 Surface Area of 3D Shapes Java O(n^2) O(1) Easy geometry, count 6 faces per cube then subtract hidden overlaps, matrix, math, amazon AGAIN

Design

# Title Solution Time Space Difficulty Note Status
0146 LRU Cache Python, Java O(1) O(k) Medium design, good basic, LRU, custom class, Double Linkedlist, LinkedHashMap, OrderedDict, amazon, google, fb, apple, microsoft, uber, linkedin, neetcode150, top100liked, netflix AGAIN**************** (8)(MUST)
0225 Implement Stack using Queues Python, Java push: O(n), pop: O(1), top: O(1) O(n) Easy design, two queues, or one queue rotated after each push, LC 232, basic, amazon, microsoft, neetcode250 AGAIN** (1)(MUST)
0284 Peeking Iterator C++ Python, Java O(1) O(1) Medium design, good basic, google, apple, amazon, fb, microsoft not start*** (1)
0348 Design Tic-Tac-Toe Python, Java O(1) O(n^2) Medium design, matrix, array, 🔒, google, fb, amazon, apple, microsoft, uber AGAIN****** (5)
0353 Design Snake Game Python, Java O(1) O(s) Medium design, good trick, Deque, 🔒, amazon, google, square, microsoft, fb, apple, uber AGAIN*** (1)
0355 Design Twitter Python, Java O(klogu) O(t + f) Medium design, good trick, data structure, heapq, defaultdict, amazon, apple, microsoft, neetcode150 OK******** (6)
0362 Design Hit Counter Java O(1), amortized O(k) Medium design, 🔒, deque, sliding window count, google, amazon, apple, microsoft, uber, linkedin, bloomberg Again (1)
0379 Design Phone Directory Java O(1) O(n) Medium design, 🔒, queue, free-slot pool, google, amazon AGAIN(1)
0380 Insert Delete GetRandom O(1) Python, Java O(1) O(n) Medium design, set, list, dict, amazon, fb, google, apple, microsoft, uber, linkedin, bloomberg OK* (5)
0381 Insert Delete GetRandom O(1) - Duplicates allowed C++ Python, Java O(1) average O(n) Hard design, LC 380, hashmap of value -> index set + swap-with-last, good trick, google, amazon, fb, apple, uber, linkedin
0432 All O`one Data Structure Java O(1) per op O(n) Hard design, doubly linked list of count buckets + hashmap, LC 146, LC 460, complex, google, amazon, fb, uber, linkedin
0460 LFU Cache Python, Java O(1) O(k) Hard design, Least Frequently Used (LFU) cache, complex, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg, neetcode250 AGAIN*** (3)
0535 Encode and Decode TinyURL Python, Java O(1) O(n) Medium design, hash map, “duplicated”, “hash map collision”, uber, amazon, google, fb, microsoft OK**** (5)
0588 Design In-Memory File System Python, Java ls: O(l + klogk)
mkdir: O(l)
addContentToFile: O(l + c)
readContentFromFile: O(l + c)		 O(n + s) Hard design, dict, a bit complex basic, 🔒, shoptify, amazon, google, microsoft, uber AGAIN******* (3)
0604 Design Compressed String Iterator C++ Python, Java ctor: O(n), next/hasNext: O(1) O(n) Easy design, 🔒, decode (char, count) pairs lazily, iterator, google
0631 Design Excel Sum Formula C++ Python, Java set: O(1)
get: O((r * c)^2)
sum: O((r * c)^2)		 O(r * c) Hard design, 🔒, google, amazon, microsoft, uber
0635 Design Log Storage System C++ Python, Java put: O(1)
retrieve: O(n + dlogd)		 O(n) Medium design, 🔒, google, amazon
0641 Design Circular Deque Python, Java O(1) per op O(k) Medium design, 🔒, circular buffer or doubly linked list, LC 622, amazon, fb
0642 Design Search Autocomplete System Python, Java O(p^2) O(p * t + s) Hard design, 🔒, amazon, google, fb, apple, microsoft, uber AGAIN**** (not start) (5)
0705 Design HashSet Java O(1) average O(n) Easy design, bucket array + chaining, LC 706, good basic, google, microsoft, neetcode250
0706 Design HashMap Java O(1) average O(n) Easy design, bucket array + chaining, LC 705, good basic, google, amazon, fb, apple, microsoft, uber, linkedin, neetcode250
0715 Range Module C++ Python, Java add: O(n)
remove: O(n)
query: O(logn)		 O(n) Hard design, sorted interval list with binary search, LC 352, TreeMap, segment tree, google, amazon, fb, linkedin
0716 Max Stack Python, Java push: O(logn)
pop: O(logn)
popMax: O(logn)
top: O(1)
peekMax: O(1)		 O(n) Hard design, basic, stack, amazon, google, fb, apple, microsoft, uber, linkedin, bloomberg again*
0745 Prefix and Suffix Search Python, Java ctor: O(w * l^2)
search : O(p + s)		 O(t) Hard design, Trie, fb, google Not start* (1) (good basic)
0900 RLE Iterator C++ Python, Java O(n) O(1) Medium design, google, treemap, array, amazon AGAIN (not start) (1)
1146 Snapshot Array Java set: O(1)
get: O(logn)		 O(n) Medium design, treeMap, binary search, google, amazon, fb, apple, microsoft, uber AGAIN*** (1)
1166 Design File System C++ Python, Java create: O(n)
get: O(n)		 O(n) Medium design, 🔒, google, airbnb, amazon, microsoft AGAIN***** (1)
1172 Dinner Plate Stacks C++ Python, Java push: O(logn)
pop: O(1), amortized
popAtStack: (logn)		 O(n * c) Hard design, PQ of indices of non-full stacks, good trick
1188 Design Bounded Blocking Queue Java O(1) per op O(k) Medium design, google, Semaphore, concurrency, amazon, apple, microsoft, uber, linkedin AGAIN (not start)
1206 Design Skiplist C++ Python, Java O(logn), on average O(n) Hard design, probabilistic multi-level linked list, complex, google, fb, microsoft
1236 Web Crawler C++ Python O(V + E) O(V) Medium design, 🔒, BFS, DFS, string, google, amazon, fb, microsoft
1244 Design A Leaderboard Python, Java ctor: O(1)
add: O(1)
top: O(n)
reset: O(1)		 O(n) Medium design, google, hashmap, amazon, fb, uber AGAIN (not start)
1268 Search Suggestions System Python, Java ctor: O(n * l)
suggest: O(l^2)		 O(t) Medium design, good basic, array, heap, sort, Trie, amazon, string, binary search, google, apple, microsoft AGAIN******** (3)
1286 Iterator for Combination Python ctor: O(1), next: O(k) O(k) Medium design, Stack, google, uber
1381 Design a Stack With Increment Operation Java O(1) per op O(n) Medium design, array, stack, lazy increment (good trick), linked list, google, amazon AGAIN (1)
1429 First Unique Number Python, Java O(1) amortized per op O(n) Medium design, good trick, heap, amazon, fb AGAIN*** (not start)
1472 Design Browser History Python, Java visit: O(1), back/forward: O(steps) O(n) Medium design, two stacks, or a list with a cursor, good basic, google, amazon, microsoft AGAIN
1500 Design a File Sharing System Python, Java join/leave: O(logn), request: O(n) O(n) Medium design, 🔒, min-heap of free ids + hashmap of owners, google AGAIN*** (not start)
1603 Design Parking System Python, Java O(1) O(1) Easy design, amazon, paypal, google, microsoft OK
1628 Design an Expression Tree With Evaluate Function Python, Java build: O(n), evaluate: O(n) O(n) Medium design, complex, amazon AGAIN*** (not start)
1656 Design an Ordered Stream Python, Java insert: O(1) amortized O(n) Easy design, pointer + bucket array, return the contiguous chunk, basic
1670 Design Front Middle Back Queue Python, Java O(1) per op O(n) Medium design, good basic, amazon AGAIN** (1) (not start)
1756 Design Recent Used Queue Python, Java fetch: O(k) O(n) Medium design, 🔒, move-to-front list or BIT, LC 146, google AGAIN
1797 Design Authentication Manager Python, Java O(1) amortized O(n) Medium design, hashmap AGAIN
1976 Number of Ways to Arrive at Destination Python, Java O(e * logn) O(n + e) Medium design, Dijkstra + count shortest paths, dp, mod 1e9+7, graph, topological sort, fb
2034 Stock Price Fluctuation Python, Java update: O(logn)
current: O(1)
maximum/minimum: O(logn) amortized		 O(n) Medium design, hashmap is the source of truth + two lazy heaps, pop stale tops instead of deleting, heap, good trick, LC weekly AGAIN******** (1) (MUST)

Prefix Sum

# Title Solution Time Space Difficulty Note Status
1124 Longest Well-Performing Interval Python, Java O(n) O(n) Medium prefix sum, hashmap, first idx, Monotonic Stack, good basic, google AGAIN************* (3)(MUST)
2012 Sum of Beauty in the Array Python O(n) O(n) Medium prefix sum, good basics, prefix, suffix sum, LC weekly AGAIN****** (2)
2017 Grid Game Python O(n) O(1) Medium prefix sum, 2 x n grid, path == turning column, prefix (bottom) + suffix (top) sum, minimax, greedy, LC weekly AGAIN(1)
4058 Maximum Pulse Value After One Subarray Rotation Python O(n) O(1) Medium prefix sum, left rotate flips sign of nums[l+1…r], gain = P[r] - P[l] + (sign[r] - sign[l]) * nums[l], best left end so far split by sign, NOT just a swap, LC weekly AGAIN(1)

Simulation

# Title Solution Time Space Difficulty Note Status
0874 Walking Robot Simulation C++ Python, Java O(n + k) O(k) Easy simulation, hashset of obstacles, direction array, LC 1041, good basic, amazon

Concurrency

# Title Solution Time Space Difficulty Note Status
1114 Print in Order C++ Python O(n) O(1) Easy concurrency, two semaphores (or CountDownLatch), enforce sequential ordering, google, amazon, apple, microsoft, bloomberg
1115 Print FooBar Alternately C++ Python O(n) O(1) Medium concurrency, two semaphores alternating foo/bar
1116 Print Zero Even Odd C++ Python O(n) O(1) Medium concurrency, three semaphores: zero releases even or odd
1117 Building H2O C++ Python O(n) O(1) Hard concurrency, two semaphores sized 2 (H) and 1 (O), barrier per molecule, linkedin
1188 Design Bounded Blocking Queue C++ Python O(1) per op O(k) Medium concurrency, 🔒, BlockingQueue with a Condition, or two counting semaphores, producer-consumer, google, amazon, apple, microsoft, uber, linkedin
1195 Fizz Buzz Multithreaded C++ Python O(n) O(1) Medium concurrency, four semaphores, one per printer, LC 412, apple, microsoft
1226 The Dining Philosophers C++ Python O(n) O(1) Medium concurrency, resource ordering, or allow at most 4 diners, deadlock avoidance, google, apple
1242 Web Crawler Multithreaded C++ Python O(|V| + |E|) O(|V|) Medium concurrency, 🔒, BFS, DFS, thread pool, fb, microsoft
1279 Traffic Light Controlled Intersection C++ Python O(n) O(1) Easy concurrency, 🔒, single lock guarding the shared green-light state

SQL

# Title Solution Time Space Difficulty Note Status
0175 Combine Two Tables MySQL O(m + n) O(m + n) Easy sql, left join on two tables, good basic, google, amazon, fb, apple OK (4)
0176 Second Highest Salary MySQL O(n) O(1) Easy sql, amazon, fb, google, apple, microsoft OK (4)
0177 Nth Highest Salary MySQL O(n^2) O(n) Medium sql, MySQL PROCEDURE, SQL FAQ, google, amazon, fb, apple, uber AGAIN*** (3)
0178 Rank Scores MySQL O(n^2) O(n) Medium sql, trick, SQL var, ank, select same table, rank, amazon, fb, apple AGAIN****** (7)
0180 Consecutive Numbers MySQL O(n) O(n) Medium sql, SQL var, join same table multi times, amazon OK* (3)
0181 Employees Earning More Than Their Managers MySQL O(n^2) O(1) Easy sql, self join on manager id, good basic, google, amazon, fb, apple OK
0182 Duplicate Emails MySQL O(n^2) O(n) Easy sql, group by + having count > 1, good basic OK
0183 Customers Who Never Order MySQL O(n^2) O(1) Easy sql, left join, amazon OK** (3) (but again)
0184 Department Highest Salary MySQL O(n^2) O(n) Medium sql, trick, where, good basic, amazon, fb, apple, microsoft OK***** (but again) (6)
0185 Department Top Three Salaries MySQL O(n^2) O(n) Hard sql, similiar as # 0177 Nth Highest Salary, good trick, top N in group, google, amazon, uber, netflix AGAIN******** (5)
0196 Delete Duplicate Emails MySQL O(n^2) O(n) Easy sql, DELETE with self join, good basic, SQL FAQ, amazon, fb AGAIN (2)
0197 Rising Temperature MySQL O(n^2) O(n) Easy sql, self join on date - 1, or LAG window function, amazon OK
0262 Trips and Users MySQL O((t * u) + tlogt) O(t) Hard sql, case condisions, amazon, fb, uber OK* (2)
0511 Game Play Analysis I MySQL O(n) O(n) Easy sql, 🔒, amazon OK
0512 Game Play Analysis II MySQL O(n) O(n) Easy sql, 🔒, 2 col where good trick AGAIN**(4)
0534 Game Play Analysis III MySQL O(nlogn) O(n) Medium sql, 🔒, SQL var, tricky, window func AGAIN******** (6)
0550 Game Play Analysis IV MySQL O(n) O(n) Medium sql, case, fraction, join, good basic, where min condition OK*********** (7) (but again)
0569 Median Employee Salary MySQL O(n) O(n) Medium sql, medium number, google AGAIN* (not start)
0571 Find Median Given Frequency of Numbers MySQL O(n) O(n) Medium sql, medium number AGAIN** (not start) (2)
0577 Employee Bonus MySQL O(n) O(n) Easy sql, left join + where is null or condition, good basic OK
0578 Get Highest Answer Rate Question MySQL O(m + n) O(n) Medium sql, fb, case condition OK* (3)
0579 Find Cumulative Salary of an Employee MySQL O(n^2) O(n) Hard sql, window function, amazon, good trick OK***** (5)(but again)
0580 Count Student Number in Departments MySQL O(m + n) O(n) Medium sql, 🔒, left join + group by, count students per department OK*** (2) (but again)
0595 Big Countries MySQL O(n) O(n) Easy sql, simple where with an OR condition, basic, google, bloomberg OK
0597 Friend Requests I: Overall Acceptance Rate MySQL O(n) O(n) Medium sql, select distinct, ifnull, fb OK*** (7)
0601 Human Traffic of Stadium MySQL O(n) O(n) Hard sql, consecutive nums, amazon OK* (1)
0602 Friend Requests II: Who Has Most Friend? MySQL O(n) O(n) Medium sql, union all, fb, amazon OK*** (4)
0603 Consecutive Available Seats MySQL O(n^2) O(n) Medium sql, consecutive nums, good basic, cross join, amazon OK***** (3)(but again)
0618 Students Report By Geography MySQL O(nlogn) O(n) Hard sql, sql var, amazon AGAIN (not start)
0620 Not Boring Movies MySQL O(n) O(n) Easy sql, simple where + order by, basic OK
0626 Exchange Seats MySQL O(n) O(n) Medium sql, CASE on id parity, count total rows, good trick, amazon AGAIN (not start)
0627 Swap Salary MySQL O(n) O(n) Easy sql, UPDATE with CASE, good basic, amazon OK* (1) (but again)
1045 Customers Who Bought All Products MySQL O(n + k) O(n + k) Medium sql, 🔒, where with count, amazon OK*** (4)
1050 Actors and Directors Who Cooperated At Least Three Times MySQL O(n) O(n) Easy sql, 🔒, amazon OK
1068 Product Sales Analysis I MySQL O(m + n) O(m + n) Easy sql, 🔒, amazon OK
1069 Product Sales Analysis II MySQL O(n) O(n) Easy sql, 🔒, amazon OK
1070 Product Sales Analysis III MySQL O(n) O(n) Medium sql, 🔒, amazon OK
1075 Project Employees I MySQL O(m + n) O(m + n) Easy sql, 🔒, fb OK
1076 Project Employees II MySQL O(n) O(n) Easy sql, 🔒, fb OK (2)
1077 Project Employees III MySQL O((m + n)^2) O(m + n) Medium sql, 🔒, tricky where, fb OK***** (2) (but again)
1082 Sales Analysis I MySQL O(n) O(n) Easy sql, 🔒, group by only 1 col, good basic, amazon OK***** (5) (again)
1083 Sales Analysis II MySQL O(m + n) O(m + n) Easy sql, 🔒, not in, amazon OK*** (3) (again)
1084 Sales Analysis III MySQL O(m + n) O(m + n) Easy sql, 🔒, amazon OK** (2)
1097 Game Play Analysis V MySQL O(n^2) O(n) Hard sql, 🔒, good basic, retention, case condition, data_add, left join AGAIN******* (8)
1098 Unpopular Books MySQL O(m + n) O(n) Medium sql, 🔒, where not in, amazon OK* (2)
1107 New Users Daily Count MySQL O(n) O(n) Medium sql, 🔒, amazon, linkedin OK*
1112 Highest Grade For Each Student MySQL O(nlogn) O(n) Medium sql, 🔒, good basic OK** (4)
1113 Reported Posts MySQL O(n) O(n) Easy sql, 🔒, fb OK
1126 Active Businesses MySQL O(n) O(n) Medium sql, 🔒, good basic AGAIN*** (3)
1127 User Purchase Platform MySQL O(n) O(n) Hard sql, 🔒, complex, union all, case, linkedin OK**** (6) (but again)
1132 Reported Posts II MySQL O(m + n) O(n) Medium sql, 🔒, fb OK*** (4)
1141 User Activity for the Past 30 Days I MySQL O(n) O(n) Easy sql, 🔒, fb AGAIN* (2)
1142 User Activity for the Past 30 Days II MySQL O(n) O(n) Easy sql, 🔒, fb AGAIN* (1)
1148 Article Views I MySQL O(nlogn) O(n) Easy sql, 🔒, linkedin OK
1149 Article Views II MySQL O(nlogn) O(n) Medium sql, 🔒, amazon, linkedin OK*
1158 Market Analysis I MySQL O(m + n) O(m + n) Medium sql, 🔒, case when ... is not null AGAIN**** (5)
1159 Market Analysis II MySQL O(m + n) O(m + n) Hard sql, 🔒, good trick AGAIN** (3)
1164 Product Price at a Given Date MySQL O(mlogn) O(m) Medium sql, 🔒, good trick, union, case, not in a period, amazon AGAIN******** (2)
1173 Immediate Food Delivery I MySQL O(n) O(1) Easy sql, 🔒 OK
1174 Immediate Food Delivery II MySQL O(n) O(m) Medium sql, 🔒 OK**** (3)
1179 Reformat Department Table MySQL O(n) O(n) Easy sql, 🔒, amazon, apple OK
1193 Monthly Transactions I MySQL O(n) O(n) Medium sql, 🔒 OK (2)
1194 Tournament Winners MySQL O(m + n + nlogn) O(m + n) Hard sql, 🔒 AGAIN*
1204 Last Person to Fit in the Elevator MySQL O(nlogn) O(n) Medium sql, 🔒, cumsum, window func, good basic OK****** (3)
1205 Monthly Transactions II MySQL O(n) O(n) Medium sql, 🔒, good trick, union all, case conditions OK*** (3) (but again)
1211 Queries Quality and Percentage MySQL O(n) O(n) Easy sql, avg with CASE, round, good basic, fb OK
1212 Team Scores in Football Tournament MySQL O(nlogn) O(n) Medium sql, good trick OK** (2)
1225 Report Contiguous Dates MySQL O(nlogn) O(n) Hard sql, 🔒, amazon, fb AGAIN* (2) (not start)
1241 Number of Comments per Post MySQL O(n) O(n) Easy sql, 🔒, good basic, fb OK**** (5) (but again)
1251 Average Selling Price MySQL O(n) O(n) Easy sql, 🔒, good basic, amazon OK*** (but again) (3)
1264 Page Recommendations MySQL O(m + n) O(m) Medium sql, 🔒, fb OK** (2)
1270 All People Report to the Given Manager MySQL O(n) O(n) Medium sql, 🔒, good basic, google, amazon OK* (3)
1280 Students and Examinations MySQL O((m * n) * log(m * n)) O(m * n) Easy sql, 🔒 OK (1)
1285 Find the Start and End Number of Continuous Ranges MySQL O(n) O(n) Medium sql, 🔒, variable, amazon AGAIN (not start) (1)
1294 Weather Type in Each Country MySQL O(m + n) O(n) Easy sql, 🔒 OK (1)
1303 Find the Team Size MySQL O(n) O(n) Easy sql, 🔒, amazon ok (1)
1308 Running Total for Different Genders MySQL O(nlogn) O(n) Medium sql, 🔒, good basic, union all, window func OK**** (3)
1321 Restaurant Growth MySQL O(n^2) O(n) Medium sql, 🔒, good basic, trick, amazon AGAIN***** (3)
1322 Ads Performance MySQL O(nlogn) O(n) Easy sql, 🔒, good basic, fb OK******* (3) (but again)
1327 List the Products Ordered in a Period MySQL O(n) O(n) Easy sql, 🔒, amazon OK
1336 Number of Transactions per Visit MySQL O(m + n) O(m + n) Medium sql, 🔒, complex, variable AGAIN (not start)
1341 Movie Rating MySQL O(nlogn) O(n) Medium sql, 🔒 AGAIN (not start)
1350 Students With Invalid Departments MySQL O(n) O(n) Easy sql, 🔒, amazon OK
1355 Activity Participants MySQL O(n) O(n) Medium sql, 🔒 OK
1364 Number of Trusted Contacts of a Customer MySQL O(n + m + l + nlogn) O(n + m + l) Medium sql, 🔒 OK
1369 Get the Second Most Recent Activity MySQL O(nlogn) O(n) Hard sql, 🔒, union, having OK** (2) (but again)
1378 Replace Employee ID With The Unique Identifier MySQL O(n) O(n) Easy sql, 🔒 OK
1384 Total Sales Amount by Year MySQL O(nlogn) O(n) Hard sql, 🔒, complex OK*
1393 Capital Gain/Loss MySQL O(n) O(n) Medium sql, 🔒 OK
1398 Customers Who Bought Products A and B but Not C MySQL O(m + n) O(m + n) Medium sql, 🔒, amazon, fb OK
1407 Top Travellers MySQL O(m + nlogn) O(m + n) Easy sql, 🔒, ifnull OK*
1412 Find the Quiet Students in All Exams MySQL O(m + nlogn) O(m + n) Hard sql, 🔒, good trick, not in, inner join on multiple cols OK**** (3) (but again)
1421 NPV Queries MySQL O(n) O(n) Medium sql, 🔒, amazon OK
1435 Create a Session Bar Chart MySQL O(n) O(1) Easy sql, 🔒 OK
1440 Evaluate Boolean Expression MySQL O(n) O(n) Medium sql, 🔒 OK
1445 Apples & Oranges MySQL O(n) O(n) Medium sql, 🔒, fb OK
1454 Active Users MySQL O(nlogn) O(n) Medium sql, 🔒, good basic, window func, amazon AGAIN*** (2)
1459 Rectangles Area MySQL O(n^2) O(n^2) Medium sql, 🔒 OK*
1468 Calculate Salaries MySQL O(m + n) O(m + n) Easy sql, 🔒 OK*
1479 Sales by Day of the Week MySQL O(m + n) O(n) Hard sql, 🔒, case, DAYOFWEEK, amazon OK
1484 Group Sold Products By The Date MySQL O(nlogn) O(n) Easy sql, 🔒, GROUP_CONCAT OK*
1495 Friendly Movies Streamed Last Month MySQL O(n) O(n) Easy sql, 🔒, amazon OK
1501 Countries You Can Safely Invest In MySQL O(n) O(n) Medium sql, 🔒, good trick, group avg, global avg, SUBSTRING, inner join on or conditions OK****** (4)
1511 Customer Order Frequency MySQL O(n) O(n) Easy sql, 🔒, having, like, amazon, fb OK* (1)
1517 Find Users With Valid E-Mails MySQL O(n) O(n) Easy sql, 🔒, regular expression, apple AGAIN
1527 Patients With a Condition MySQL O(n) O(n) Easy sql, 🔒 OK
1532 The Most Recent Three Orders MySQL O(nlogn) O(n) Medium sql, 🔒, window func, good basic OK** (2) (but again)
1543 Fix Product Name Format MySQL O(nlogn) O(n) Easy sql, 🔒, trim OK
1549 The Most Recent Orders for Each Product MySQL O(nlogn) O(n) Medium sql, 🔒, max day per id, good basic OK* (again)
1555 Bank Account Summary MySQL O(m + n) O(m + n) Medium sql, 🔒, union all, good trick OK**** (2)(but again)
1565 Unique Orders and Customers Per Month MySQL O(n) O(n) Easy sql, 🔒 OK
1571 Warehouse Manager MySQL O(n) O(n) Medium sql, 🔒, amazon OK* (1)
1581 Customer Who Visited but Did Not Make Any Transactions MySQL O(n) O(n) Easy sql, 🔒, left join, good basic OK** (2)(but again)
1587 Bank Account Summary II MySQL O(m + n) O(m + n) Easy sql, 🔒 OK
1596 The Most Frequently Ordered Products for Each Customer MySQL O(n) O(n) Medium sql, 🔒, good trick, rank() ORDER BY count, get max in each group, amazon OK********* (3)(but again)
1607 Sellers With No Sales MySQL O(nlogm) O(n + m) Medium sql, 🔒 OK
1613 Find the Missing IDs MySQL O(n^2) O(n) Medium sql, 🔒, RECURSIVE CTE, good trick, amazon AGAIN*** (2)
1623 All Valid Triplets That Can Represent a Country MySQL O(n^3) O(n^3) Easy sql, 🔒, <>, amazon AGAIN* (not start)
1633 Percentage of Users Attended a Contest MySQL O(m + nlogn) O(n) Easy sql, 🔒 OK
1635 Hopper Company Queries I MySQL O(d + r + tlogt) O(d + r + t) Hard sql, 🔒, complex, uber AGAIN (not start)
1645 Hopper Company Queries II MySQL O(d + r + tlogt) O(d + r + t) Hard sql, 🔒, complex, uber AGAIN (not start)
1651 Hopper Company Queries III MySQL O(d + r + tlogt) O(d + r + t) Hard sql, 🔒, complex, uber AGAIN (not start)
1661 Average Time of Process per Machine MySQL O(n) O(n) Easy sql, 🔒, good basic, amazon, fb OK* (1)
1667 Fix Names in a Table MySQL O(nlogn) O(n) Easy sql, 🔒, concat, sub-string OK (1)
1677 Product’s Worth Over Invoices MySQL O(nlogn) O(n) Easy sql, 🔒 OK
1683 Invalid Tweets MySQL O(n) O(n) Easy sql, 🔒 OK
1693 Daily Leads and Partners MySQL O(n) O(n) Easy sql, 🔒 OK
1699 Number of Calls Between Two Persons MySQL O(n) O(n) Medium sql, 🔒, cte, union all, amazon, fb OK* (1)(but again)
1709 Biggest Window Between Visits MySQL O(nlogn) O(n) Medium sql, 🔒, window func, datediff, coalesce, good trick AGAIN***** (2)
1715 Count Apples and Oranges MySQL O(n) O(n) Medium sql, 🔒, ifnull OK (2)
1729 Find Followers Count MySQL O(nlogn) O(n) Easy sql, 🔒 OK
1731 The Number of Employees Which Report to Each Employee MySQL O(nlogn) O(n) Easy sql, 🔒 OK
1741 Find Total Time Spent by Each Employee MySQL O(nlogn) O(n) Easy sql, 🔒, amazon OK
1747 Leetflex Banned Accounts MySQL O(n^2) O(n) Medium sql, 🔒 OK (2) (but again)
1757 Recyclable and Low Fat Products MySQL O(n) O(n) Easy sql, 🔒, fb OK
1767 Find the Subtasks That Did Not Execute MySQL O(n * c) O(n * c) Hard sql, 🔒, RECURSIVE CTE, google AGAIN (not start)
1777 Product’s Price for Each Store MySQL O(n) O(n) Easy sql, 🔒, amazon OK (2)
1783 Grand Slam Titles MySQL O(n) O(n) Medium sql, 🔒, union all, good basic, amazon OK* (1) (but again)
1789 Primary Department for Each Employee MySQL O(n) O(n) Easy sql, 🔒, where id in OK (1) (but again)
1795 Rearrange Products Table MySQL O(n) O(n) Easy sql, 🔒, union all, good basic, amazon OK****** (2)
1809 Ad-Free Sessions MySQL O(n) O(n) Easy sql, 🔒, left join where col is null, amazon OK**** (3)(but again)
1811 Find Interview Candidates MySQL O(nlogn) O(n) Medium sql, 🔒, union all, cte, where, good basic, amazon AGAIN* (2)
1821 Find Customers With Positive Revenue this Year MySQL O(n) O(n) Easy sql, 🔒, google OK
1831 Maximum Transaction Each Day MySQL O(nlogn) O(n) Medium sql, 🔒, rank(), where on 2 attr, good basic AGAIN**** (2)
1841 League Statistics MySQL O(nlogn) O(n) Medium sql, 🔒, case, complex AGAIN* (2)
1843 Suspicious Bank Accounts MySQL O(nlogn) O(n) Medium sql, 🔒, good trick, window func OK** (2) (but AGAIN)
1853 Convert Date Format MySQL O(n) O(n) Easy sql, 🔒 OK
1867 Orders With Maximum Quantity Above Average MySQL O(n) O(n) Easy sql, 🔒 OK (1)
1873 Calculate Special Bonus MySQL O(n) O(n) Easy sql, 🔒, left, odd num OK (2)
1875 Group Employees of the Same Salary MySQL O(nlogn) O(n) Medium sql, 🔒, complex, good basic AGAIN* (1)
1890 The Latest Login in 2020 MySQL O(n) O(n) Easy sql, 🔒 OK
1892 Page Recommendations II MySQL O(n * m) O(n * m) Hard sql, 🔒, join on friendship + page likes, not in, fb AGAIN*** (1) (not start)
1907 Count Salary Categories MySQL O(n) O(n) Medium sql, 🔒, union all OK* (1)
1917 Leetcodify Friends Recommendations MySQL O(n^2) O(n^2) Hard sql, 🔒, NOT EXISTS AGAIN*** (2)
1919 Leetcodify Similar Friends MySQL O(n * l) O(n * l) Hard sql, 🔒 AGAIN* (not start)
1934 Confirmation Rate MySQL O(n + m) O(n + m) Medium sql, 🔒, good basic OK* (1) (but again)
1939 Users That Actively Request Confirmation Messages MySQL O(nlogn) O(n) Easy sql, 🔒, TIMESTAMPDIFF, good basic OK*** (2) (but again)
1949 Strong Friendship MySQL O(n^3) O(n^2) Medium sql, 🔒, good basic, self join, where on 2 cols, fb OK* (2) (but again)
1951 All the Pairs With the Maximum Number of Common Followers MySQL O(n^3) O(n^2) Medium sql, 🔒, good trick AGAIN* (2)
1965 Employees With Missing Information MySQL O(nlogn) O(n) Easy sql, 🔒, good basic OK* (1) (but again)
1972 First and Last Call On the Same Day MySQL O(n) O(n) Hard sql, 🔒, rank, union all, amazon AGAIN** (2)
1978 Employees Whose Manager Left the Company MySQL O(nlogn) O(n) Easy sql, 🔒 OK (1)
1988 Find Cutoff Score for Each School MySQL O(n * m) O(n * m) Medium sql, 🔒, no ref AGAIN (not start)
1990 Count the Number of Experiments MySQL O(n) O(n) Easy sql, 🔒, cross join AGAIN* (1)
2004 The Number of Seniors and Juniors to Join the Company MySQL O(nlogn) O(n) Hard sql, 🔒, not ref AGAIN (not start)

Shell Script

# Title Solution Time Space Difficulty Note Status
0192 Word Frequency Shell O(n) O(k) Medium shell, awk word count then sort by frequency, good basic, google, amazon, fb, apple
0193 Valid Phone Numbers Shell O(n) O(1) Easy shell, grep with a regular expression, basic, amazon, apple, uber
0194 Transpose File Shell O(n^2) O(n^2) Medium shell, awk transpose with a 2D array, good trick
0195 Tenth Line Shell O(n) O(1) Easy shell, sed / awk NR == 10, basic, google, apple

Newly Added (kamyu104 gap)

Problems imported from the coverage audit against kamyu104/LeetCode-Solutions.

These solutions were generated from the problem statements and have not been run against LeetCode’s judge. Treat them as drafts to review, not as verified-accepted answers.

Ranges covered so far: 0001-1000 (116 problems) and 1001-3687 (1855 problems) — 1971 in total. Every row here carries the status imported; the practised rows are in the main tables above.

Array

# Title Solution Time Space Difficulty Note Status
0158 Read N Characters Given read4 II - Call Multiple Times Python, Java O(n) per read O(1) Hard array, 🔒, LC 157, carry the read4 buffer across calls, good trick, google, fb, new, amazon, apple, microsoft, uber, bloomberg imported
0296 Best Meeting Point Python, Java O(m * n) O(m + n) Hard array, 🔒, median of the row and column coordinates, Manhattan distance, math, good trick, new, google, amazon, fb, linkedin imported
0485 Max Consecutive Ones Python, Java O(n) O(1) Easy array, running count of consecutive 1s, LC 487, LC 1004, basic, new, google, amazon, fb, apple, microsoft imported
0487 Max Consecutive Ones II Python, Java O(n) O(1) Medium array, 🔒, sliding window allowing one flip, LC 1004, good basic, new, google, amazon, fb, microsoft imported
0495 Teemo Attacking Python, Java O(n) O(1) Easy array, sum of min(duration, gap), interval merge, basic, new imported
0644 Maximum Average Subarray II Python, Java O(n * log((max - min) / eps)) O(1) Hard array, 🔒, binary search on the real-valued average + prefix sum, LC 643, good trick, new, google imported
0732 My Calendar III Python, Java O(nlogn) per book O(n) Hard array, LC 729, LC 731, sweep line over a TreeMap of deltas, segment tree, good trick, new, binary search, design, google, amazon, fb, apple imported
0803 Bricks Falling When Hit Python, Java O((m * n + h) * a(m * n)) O(m * n) Hard array, reverse thinking, union find with a virtual roof node, LC 200, complex, new, google imported
0927 Three Equal Parts Python, Java O(n) O(1) Hard array, count the ones then match the suffix blocks, good trick, new imported
0952 Largest Component Size by Common Factor Python, Java O(n * sqrt(M) * a(M)) O(M) Hard array, union find over prime factors, sieve, complex, new, google imported
0985 Sum of Even Numbers After Queries Python, Java O(n + m) O(1) excluding output Medium array, maintain a running even-sum and apply deltas, good basic, new imported
0999 Available Captures for Rook Python, Java O(m * n) O(1) Easy array, scan the 4 directions from the rook, matrix, basic, new imported
1002 Find Common Characters Python O(n * L), n = len(words), L = avg word length O(1), at most 26 letters Easy array, COUNTER + take the MIN count of each char over all words, new, google, amazon, fb, apple, uber imported
1013 Partition Array Into Three Parts With Equal Sum Python O(n) O(1) Easy array, PREFIX SUM + GREEDY, new, amazon, microsoft imported
1018 Binary Prefix Divisible By 5 Python O(n) O(1), excluding the output Easy array, RUNNING REMAINDER (mod 5), new imported
1030 Matrix Cells in Distance Order Python O(m * n * log(m * n)) O(m * n) Easy array, SORT BY MANHATTAN DISTANCE, new imported
1051 Height Checker Python O(n log n) O(n) Easy array, SORT A COPY + COMPARE INDEX BY INDEX, new, amazon, apple imported
1052 Grumpy Bookstore Owner Python O(n) O(1) Medium array, FIXED-SIZE SLIDING WINDOW, new, uber imported
1072 Flip Columns For Maximum Number of Equal Rows Python O(m * n) O(m * n) Medium array, HASH MAP + row “normalization”, new imported
1085 Sum of Digits in the Minimum Number Python O(n) O(1) Easy array, 🔒, find min, sum its digits, return the INVERTED parity, new, amazon imported
1093 Statistics from a Large Sample Python O(256) O(1) Medium array, COUNTING ARRAY (bucket) + prefix walk for the median, new, microsoft imported
1144 Decrease Elements To Make Array Zigzag Python O(n) O(1) Medium array, GREEDY + ENUMERATE THE 2 PARITIES, new, google imported
1184 Distance Between Bus Stops Python O(n) O(1) Easy array, PREFIX SUM on a circle (one arc + its complement), new, google imported
1200 Minimum Absolute Difference Python O(n log n) O(n) Easy array, SORT + ADJACENT PAIRS, new, google, amazon, uber imported
1222 Queens That Can Attack the King Python O(8 * 8) O(n) Medium array, SIMULATION / RAY CASTING FROM THE KING, new, amazon, microsoft imported
1252 Cells with Odd Values in a Matrix Python O(m + n + k), k = len(indices) O(m + n) Easy array, COUNT ROWS / COLS ONLY + PARITY MATH, new, google imported
1260 Shift 2D Grid Python O(m * n) O(m * n) Easy array, FLATTEN THE GRID + INDEX MATH, new, amazon imported
1267 Count Servers that Communicate Python O(m * n) O(m + n) Medium array, COUNTING (row count + col count), new, google, microsoft imported
1295 Find Numbers with Even Number of Digits Python O(n log M), M = max(nums) O(log M) Easy array, cast to STRING and check the length parity, new, amazon imported
1304 Find N Unique Integers Sum up to Zero Python O(n) O(n) Easy array, MATH (emit symmetric +/- pairs, plus a lone 0 when n is odd), new, amazon, apple, microsoft imported
1313 Decompress Run-Length Encoded List Python O(n + k), k = total output length O(1) extra, excluding the output list Easy array, simulation, walk the array 2 elements at a time, new, google, amazon, apple imported
1333 Filter Restaurants by Vegan-Friendly, Price and Distance Python O(n + k log k) O(k) (k = number of survivors) Medium array, FILTER + SORT (by (-rating, -id)), new, amazon imported
1337 The K Weakest Rows in a Matrix Python O(m log n + m log m) O(m) Easy array, BINARY SEARCH (count 1’s per row) + SORT by (count, idx), new, amazon imported
1343 Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold Python O(n) O(1) Medium array, SLIDING WINDOW (fixed size k), new imported
1346 Check If N and Its Double Exist Python O(n) O(n) Easy array, HASH SET (one pass), new, google, apple imported
1351 Count Negative Numbers in a Sorted Matrix Python O(m + n) O(1) Easy array, STAIRCASE SEARCH from the bottom-left corner, new, amazon, fb, apple, microsoft imported
1389 Create Target Array in the Given Order Python O(n^2) O(n) Easy array, DIRECT SIMULATION (list.insert already does the shifting), new, amazon, apple imported
1394 Find Lucky Integer in an Array Python O(n) O(n) Easy array, COUNTING (a value is lucky when count == value), new imported
1399 Count Largest Group Python O(n * log n) O(log n) Easy array, COUNTING BY DIGIT SUM (bucket key = sum of digits), new imported
1404 Number of Steps to Reduce a Number in Binary Representation to One Python O(n) O(1) Medium array, BIT SIMULATION (carry), scan from the LSB, new, amazon imported
1413 Minimum Value to Get Positive Step by Step Sum Python O(n) O(1) Easy array, PREFIX SUM, new imported
1426 Counting Elements Python O(n) O(n) Easy array, 🔒, HASH TABLE (counter), new imported
1427 Perform String Shifts Python O(n + m) O(n) Easy array, 🔒, MATH (collapse all shifts into ONE net left-shift), new imported
1428 Leftmost Column with at Least a One Python O(m + n) O(1) Medium array, 🔒, STAIRCASE SEARCH (start from TOP-RIGHT corner), new, fb, uber imported
1437 Check If All 1’s Are at Least Length K Places Away Python O(n) O(1) Easy array, ONE PASS, TRACK PREVIOUS 1 INDEX, new imported
1450 Number of Students Doing Homework at a Given Time Python O(n) O(1) Easy array, LINEAR SCAN, count intervals covering queryTime, new imported
1460 Make Two Arrays Equal by Reversing Sub-arrays Python O(n) O(n) Easy array, MULTISET EQUALITY (reversals generate every permutation), new, fb imported
1464 Maximum Product of Two Elements in an Array Python O(n) O(1) Easy array, TRACK THE TWO LARGEST VALUES (all values are positive), new, fb imported
1465 Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts Python O(m log m + n log n) O(m + n) Medium array, SORT + LARGEST GAP (height and width are independent), new, amazon imported
1471 The k Strongest Values in an Array Python O(n log n) O(n) Medium array, SORT TWICE (find the centre, then rank by the custom “strength”), new, google imported
1475 Final Prices With a Special Discount in a Shop Python O(n) O(n) Easy array, MONOTONIC STACK (“next smaller OR equal element to the right”), new, amazon, uber imported
1480 Running Sum of 1d Array Python O(n) O(1) Easy array, PREFIX SUM IN PLACE, new, google, amazon, apple, microsoft, uber imported
1491 Average Salary Excluding the Minimum and Maximum Salary Python O(n) O(1) Easy array, SUM MINUS THE EXTREMES (no sorting needed), new, amazon imported
1502 Can Make Arithmetic Progression From Sequence Python O(n log n) O(n) Easy array, SORT + CHECK ADJACENT DIFF, new, amazon imported
1503 Last Moment Before All Ants Fall Out of a Plank Python O(n) O(1) Medium array, BRAIN TEASER, new, google imported
1534 Count Good Triplets Python O(n^3) O(1) Easy array, BRUTE FORCE ENUMERATION WITH EARLY PRUNING, new, google, amazon, apple imported
1535 Find the Winner of an Array Game Python O(n) O(1) Medium array, ONE LINEAR SWEEP (no queue simulation needed), new imported
1538 Guess the Majority in a Hidden Array Python O(n) calls O(1) Medium array, 🔒, COMPARE EVERY INDEX AGAINST A FIXED REFERENCE INDEX, new, google imported
1550 Three Consecutive Odds Python O(n) O(1) Easy array, RUNNING STREAK COUNTER, new imported
1559 Detect Cycles in 2D Grid Python O(m * n * alpha) O(m * n) Medium array, UNION FIND (an edge joining two already-connected cells closes a cycle), new, amazon, fb imported
1560 Most Visited Sector in a Circular Track Python O(n) O(n) Easy array, MATH (only the first and the last sector matter), new imported
1562 Find Latest Group of Size M Python O(n) O(n) Medium array, INTERVAL MERGING (track the length stored at each group’s two ends), new, google imported
1566 Detect Pattern of Length M Repeated K or More Times Python O(n) O(1) Easy array, RUN COUNTING (a period-m repeat means arr[i] == arr[i + m]), new imported
1572 Matrix Diagonal Sum Python O(n) O(1) Easy array, ARRAY (walk both diagonals at once, fix the double-counted centre), new, amazon imported
1574 Shortest Subarray to be Removed to Make Array Sorted Python O(n) O(1) Medium array, TWO POINTERS (keep a non-decreasing prefix + a non-decreasing suffix), new, amazon imported
1582 Special Positions in a Binary Matrix Python O(m * n) O(m + n) Easy array, ROW / COLUMN SUMS (a special 1 is alone in both its lines), new, google, uber imported
1583 Count Unhappy Friends Python O(n^2) O(n^2) Medium array, RANK TABLE (O(1) “does a prefer b over c ?” lookups), new imported
1619 Mean of Array After Removing Some Elements Python O(n log n) O(n) for the sorted copy Easy array, SORT + TRIM THE TWO TAILS, new, google imported
1629 Slowest Key Python O(n) O(1) Easy array, ONE PASS with a (duration, key) tie-break, new, amazon imported
1646 Get Maximum in Generated Array Python O(n) O(n) Easy array, SIMULATION (build the array left to right, every rule looks back), new imported
1652 Defuse the Bomb Python O(n) O(n) for the output Easy array, SLIDING WINDOW over the circular array, new imported
1700 Number of Students Unable to Eat Lunch Python O(n) O(1) Easy array, COUNTING (the queue ORDER is irrelevant – only how many of each type), new imported
1701 Average Waiting Time Python O(n) O(1) Medium array, SINGLE-SERVER FIFO SIMULATION (track when the chef becomes free), new imported
1706 Where Will the Ball Fall Python O(m * n) O(1) excluding the output Medium array, SIMULATION (drop each ball row by row, check the neighbour board), new, google imported
1714 Sum Of Special Evenly-Spaced Elements In Array Python O((n + q) * sqrt(n)) O(n * sqrt(n)) Hard array, 🔒, SQRT DECOMPOSITION (precompute small steps, brute force big steps), new imported
1732 Find the Highest Altitude Python O(n) O(1) Easy array, RUNNING PREFIX SUM (gain is a difference array), new, google, apple imported
1738 Find Kth Largest XOR Coordinate Value Python O(m * n * log(m * n)) O(m * n) for the value list Medium array, 2D PREFIX XOR + SORT, new, google imported
1742 Maximum Number of Balls in a Box Python O(n * log10(highLimit)) O(1) (a 55-slot array) Easy array, COUNTING BY DIGIT SUM (the box index space is tiny), new, microsoft imported
1752 Check if Array Is Sorted and Rotated Python O(n) O(1) Easy array, COUNT THE “DROPS” ON THE CIRCULAR ARRAY (a rotation has at most one), new, amazon imported
1755 Closest Subsequence Sum Python O(2^(n/2) * n) O(2^(n/2)) Hard array, MEET IN THE MIDDLE (n <= 40 -> two halves of at most 2^20 subset sums), new imported
1773 Count Items Matching a Rule Python O(n) O(1) Easy array, MAP THE RULE KEY TO A COLUMN INDEX, THEN COUNT, new, fb, apple imported
1779 Find Nearest Point That Has the Same X or Y Coordinate Python O(n) O(1) Easy array, SINGLE PASS, KEEP THE BEST VALID POINT, new, amazon imported
1800 Maximum Ascending Subarray Sum Python O(n) O(1) Easy array, RUNNING SUM OF THE CURRENT ASCENDING RUN, new imported
1826 Faulty Sensor Python O(n) O(1) Easy array, 🔒, FIRST MISMATCH + TEST BOTH SHIFT HYPOTHESES, new, fb imported
1848 Minimum Distance to the Target Element Python O(n) worst case O(1) Easy array, EXPAND OUTWARD FROM start (first hit is the answer), new imported
1861 Rotating the Box Python O(m * n) O(m * n) for the output Medium array, SIMULATE GRAVITY FIRST (in the ORIGINAL frame), THEN ROTATE, new, microsoft, uber imported
1869 Longer Contiguous Segments of Ones than Zeros Python O(n) O(1) Easy array, SINGLE PASS RUN LENGTH (track both runs at once), new, amazon imported
1878 Get Biggest Three Rhombus Sums in a Grid Python O(m * n * K^2), K = min(m, n) / 2 O(m * n * K) for the set of sums Medium array, ENUMERATE (TOP CORNER, HALF-DIAGONAL) AND WALK THE BORDER, new, apple imported
1886 Determine Whether Matrix Can Be Obtained By Rotation Python O(n^2) O(n^2) Easy array, BRUTE FORCE OVER THE 4 ROTATIONS (a 4th rotation is the identity), new, amazon imported
1895 Largest Magic Square Python O(m * n * min(m,n)^2) O(m * n) Medium array, PREFIX SUMS PER ROW / PER COLUMN + SHRINKING BRUTE FORCE, new imported
1906 Minimum Absolute Difference Queries Python O(n + q * (B + n / B)) O(n / B) Medium array, EXPLOIT THE TINY VALUE RANGE (nums[i] <= 100), new, google imported
1909 Remove One Element to Make the Array Strictly Increasing Python O(n) O(1) Easy array, GREEDY SCAN (only the FIRST bad pair matters), new, fb imported
1940 Longest Common Subsequence Between Sorted Arrays Python O(N + M), N = total elements, M = 101 O(M) Medium array, 🔒, COUNTING (every row is STRICTLY increasing -> LCS == set intersection), new, google imported
1958 Check if Move is Legal Python O(8 * 8) = O(1) O(1) Medium array, ENUMERATE 8 DIRECTIONS (walk out from the placed cell), new, amazon imported
1966 Binary Searchable Numbers in an Unsorted Array Python O(n) O(n) Medium array, 🔒, PREFIX MAX + SUFFIX MIN, new, google imported
1970 Last Day Where You Can Still Cross Python O(mn * alpha(mn)) O(m*n) Hard array, REVERSE TIME + UNION FIND (flooding is hard to undo, un-flooding is easy), new imported
1983 Widest Pair of Indices With Equal Range Sum Python O(n) O(n) Medium array, 🔒, PREFIX SUM OF THE DIFFERENCE + HASH TABLE (longest zero-sum subarray), new imported
1992 Find All Groups of Farmland Python O(m * n) O(1) besides the output Medium array, SCAN FOR TOP-LEFT CORNERS, THEN WALK THE RECTANGLE EDGES, new imported
1998 GCD Sort of an Array Python O(M log log M + n log M * alpha), M = max(nums) O(M) Hard array, SIEVE OF SMALLEST PRIME FACTOR + UNION FIND ON VALUES, new, amazon imported
2007 Find Original Array From Doubled Array Python O(n log n) O(n) Medium array, GREEDY MATCHING ON A SORTED ARRAY + COUNTER, new, google imported
2011 Final Value of Variable After Performing Operations Python O(n) O(1) Easy array, LOOK AT THE MIDDLE CHARACTER ONLY, new imported
2016 Maximum Difference Between Increasing Elements Python O(n) O(1) Easy array, RUNNING MIN (same shape as LC 121 “best time to buy and sell stock”), new imported
2018 Check if Word Can Be Placed In Crossword Python O(m * n) O(max(m, n)) Medium array, SPLIT EVERY ROW / COLUMN INTO ‘#’-FREE SLOTS, THEN MATCH, new, google, amazon imported
2022 Convert 1D Array Into 2D Array Python O(m * n) O(1) beyond the output Easy array, SLICING (only feasible when len(original) == m * n), new, google imported
2035 Partition Array Into Two Arrays to Minimize Sum Difference Python O(2^n * n) O(2^n) Hard array, MEET IN THE MIDDLE (2^30 is too big, 2 * 2^15 is not), new imported
2055 Plates Between Candles Python O(n + q) O(n) Medium array, PREFIX SUM OF PLATES + NEAREST-CANDLE ARRAYS (O(1) per query), new, amazon imported
2057 Smallest Index With Equal Value Python O(n) O(1) Easy array, LINEAR SCAN (return on the first hit -> smallest index for free), new, google imported
2078 Two Furthest Houses With Different Colors Python O(n) O(1) Easy array, THE OPTIMAL PAIR ALWAYS INVOLVES HOUSE 0 OR HOUSE n-1, new, amazon imported
2098 Subsequence of Size K With the Largest Even Sum Python O(n log n) O(n) Medium array, 🔒, TAKE THE k LARGEST, THEN FIX THE PARITY WITH ONE SWAP, new imported
2099 Find Subsequence of Length K With the Largest Sum Python O(n log n) O(n) Easy array, PICK THE k LARGEST BY INDEX, THEN RESTORE THE ORIGINAL ORDER, new imported
2100 Find Good Days to Rob the Bank Python O(n) O(n) Medium array, TWO PREFIX ARRAYS — LENGTH OF THE NON-INCREASING RUN ENDING HERE, new, amazon imported
2106 Maximum Fruits Harvested After at Most K Steps Python O(n) O(n) Hard array, SLIDING WINDOW OVER THE SORTED POSITIONS + PREFIX SUMS, new imported
2113 Elements in Array After Removing and Replacing Elements Python O(n + q) O(q) Medium array, 🔒, THE STATE IS PERIODIC WITH PERIOD 2n — ANSWER EACH QUERY IN O(1), new imported
2121 Intervals Between Identical Elements Python O(n) O(n) Medium array, GROUP THE INDICES BY VALUE, THEN ROLL THE SUM ALONG EACH GROUP, new imported
2122 Recover the Original Array Python O(n^2) O(n) Hard array, SORT, THEN TRY EVERY CANDIDATE PARTNER FOR THE SMALLEST ELEMENT, new, google imported
2128 Remove All Ones With Row and Column Flips Python O(m * n) O(n) Medium array, 🔒, EVERY ROW MUST EQUAL ROW 0 OR ITS EXACT COMPLEMENT, new, google imported
2132 Stamping the Grid Python O(m * n) O(m * n) Hard array, 2D PREFIX SUM (where can a stamp go?) + 2D DIFFERENCE ARRAY (what is covered?), new imported
2155 All Divisions With the Highest Score of a Binary Array Python O(n) O(n) for the output Medium array, ONE SWEEP, UPDATING THE SCORE INCREMENTALLY, new, google imported
2194 Cells in a Range on an Excel Sheet Python O(cols * rows) O(1) beyond the output Easy array, NESTED LOOPS, COLUMN OUTER AND ROW INNER, new imported
2210 Count Hills and Valleys in an Array Python O(n) O(n) Easy array, COLLAPSE EQUAL RUNS FIRST, THEN COUNT LOCAL EXTREMA, new imported
2219 Maximum Sum Score of Array Python O(n) O(1) Medium array, 🔒, PREFIX / SUFFIX SUM IN ONE PASS, new imported
2237 Count Positions on Street With Required Brightness Python O(n + len(lights)) O(n) Medium array, 🔒, DIFFERENCE ARRAY — EACH LAMP IS ONE RANGE INCREMENT, new imported
2239 Find Closest Number to Zero Python O(n) O(1) Easy array, SORT KEY = (DISTANCE TO ZERO, NEGATED VALUE), new imported
2245 Maximum Trailing Zeros in a Cornered Path Python O(m * n) O(m * n) Medium array, TRAILING ZEROS = min(#2, #5) — SO ONLY THE 2/5 EXPONENTS MATTER, new imported
2256 Minimum Average Difference Python O(n) O(1) Medium array, RUNNING PREFIX SUM, THE SUFFIX FOLLOWS FROM THE TOTAL, new imported
2270 Number of Ways to Split Array Python O(n) O(1) Medium array, PREFIX SUM (one pass, total sum known up front), new imported
2271 Maximum White Tiles Covered by a Carpet Python O(n log n) O(1) beyond the sort Medium array, SORT + SLIDING WINDOW (an optimal carpet can start on some tile’s left end), new imported
2274 Maximum Consecutive Floors Without Special Floors Python O(n log n) O(n) Medium array, SORT THE SPECIAL FLOORS AND MEASURE THE GAPS BETWEEN THEM, new imported
2293 Min Max Game Python O(n) O(n) Easy array, DIRECT SIMULATION OF THE HALVING ROUNDS, new imported
2319 Check if Matrix Is X-Matrix Python O(n^2) O(1) Easy array, DIRECT SCAN (a cell is on the X iff i == j or i + j == n - 1), new imported
2326 Spiral Matrix IV Python O(m * n) O(m * n) for the output Medium array, WALK THE SPIRAL WITH FOUR SHRINKING BOUNDARIES, new imported
2373 Largest Local Values in a Matrix Python O(n^2) O(n^2) for the output Easy array, SLIDE A 3 x 3 WINDOW AND TAKE ITS MAXIMUM, new imported
2382 Maximum Segment Sum After Removals Python O(n * alpha(n)) O(n) Hard array, RUN THE QUERIES BACKWARDS SO REMOVALS BECOME INSERTIONS (union-find), new imported
2391 Minimum Amount of Time to Collect Garbage Python O(n) O(n) Medium array, PICKUP TIME IS FIXED; ONLY THE DRIVING DEPENDS ON THE LAST HOUSE, new imported
2407 Longest Increasing Subsequence II Python O(n log V) O(V) Hard array, DP INDEXED BY VALUE, WITH A SEGMENT TREE FOR RANGE MAXIMUM, new imported
2428 Maximum Sum of an Hourglass Python O(m * n) O(1) Medium array, SLIDE THE FIXED 7-CELL SHAPE OVER EVERY 3 x 3 WINDOW, new imported
2432 The Employee That Worked on the Longest Task Python O(len(logs)) O(1) Easy array, EACH TASK’S DURATION IS THE GAP TO THE PREVIOUS LEAVE TIME, new imported
2433 Find The Original Array of Prefix Xor Python O(n) O(n) for the output Medium array, XOR IS ITS OWN INVERSE — arr[i] = pref[i] ^ pref[i-1], new imported
2438 Range Product Queries of Powers Python O(30 + q * log(sum e)) O(30 + q) Medium array, BIT DECOMPOSITION + PREFIX SUM OF EXPONENTS, new imported
2446 Determine if Two Events Have Conflict Python O(1) O(1) Easy array, INTERVAL OVERLAP ON THE RAW STRINGS (HH:MM is zero-padded -> lexicographic order == chronological order), new imported
2460 Apply Operations to an Array Python O(n) O(n) Easy array, APPLY THE MERGES LEFT TO RIGHT, THEN A STABLE ZERO-SHIFT, new imported
2482 Difference Between Ones and Zeros in Row and Column Python O(m * n) O(m + n) besides the output Medium array, ROW / COLUMN ONE-COUNTS (zeros are derived, not counted separately), new imported
2500 Delete Greatest Value in Each Row Python O(m * n * log n) O(m * n) for the transposed columns Easy array, SORT EACH ROW + SUM OF COLUMN MAX, new imported
2515 Shortest Distance to Target String in a Circular Array Python O(n * L) O(1) Easy array, ONE PASS (circular distance = min(clockwise, counter-clockwise)), new imported
2535 Difference Between Element Sum and Digit Sum of an Array Python O(n * log10(M)) O(1) Easy array, SIMULATION (accumulate both sums in one pass), new imported
2536 Increment Submatrices by One Python O(q + n^2) O(1) beyond the output Medium array, 2D DIFFERENCE ARRAY (+ 2D PREFIX SUM TO RESTORE), new imported
2559 Count Vowel Strings in Ranges Python O(n + m) O(n) Medium array, PREFIX SUM, new imported
2569 Handling Sum Queries After Update Python O(n + q * log(n)) O(n) Hard array, LAZY SEGMENT TREE (range flip / range count of ones) + RUNNING TOTAL, new imported
2574 Left and Right Sum Differences Python O(n) O(1) beyond the output Easy array, RUNNING PREFIX / SUFFIX SUM IN ONE PASS, new imported
2580 Count Ways to Group Overlapping Ranges Python O(n * log n) O(n) for the sort Medium array, SORT + MERGE INTERVALS + POWER OF TWO, new imported
2655 Find Maximal Uncovered Ranges Python O(m * log m) O(m) for the sort (m = len(ranges)) Medium array, 🔒, SORT BY LEFT ENDPOINT + SWEEP THE “FURTHEST COVERED” WATERMARK, new imported
2660 Determine the Winner of a Bowling Game Python O(n) O(1) Easy array, SIMULATION (score each player independently, then compare), new imported
2672 Number of Adjacent Elements With the Same Color Python O(n + q) O(n) Medium array, INCREMENTAL COUNTER – ONLY THE 2 PAIRS TOUCHING index CHANGE, new imported
2711 Difference of Number of Distinct Values on Diagonals Python O(m * n) O(m * n) Medium array, DIAGONAL SWEEP + PREFIX / SUFFIX DISTINCT COUNTS, new imported
2717 Semi-Ordered Permutation Python O(n) O(1) Easy array, MATH (only the positions of 1 and n matter), new imported
2733 Neither Minimum nor Maximum Python O(n) O(1) Easy array, MIN / MAX THEN FIRST SURVIVOR, new imported
2760 Longest Even Odd Subarray With Threshold Python O(n) O(1) Easy array, GREEDY SCAN WITHOUT BACKTRACKING (two pointers), new imported
2782 Number of Unique Categories Python O(n^2) haveSameCategory calls O(n) Medium array, 🔒, REPRESENTATIVE SCAN (INTERACTIVE), new imported
2798 Number of Employees Who Met the Target Python O(n) O(1) Easy array, LINEAR COUNT, new imported
2848 Points That Intersect With Cars Python O(n + M) O(M) (M = 102, the coordinate range) Easy array, DIFFERENCE ARRAY (line sweep over a tiny coordinate range), new imported
2855 Minimum Right Shifts to Sort the Array Python O(n) O(1) Easy array, COUNT THE “DROPS” (rotated sorted array detection), new imported
2873 Maximum Value of an Ordered Triplet I Python O(n) O(1) Easy array, ONE PASS, KEEP PREFIX MAX + BEST PREFIX DIFFERENCE, new imported
2903 Find Indices With Index and Value Difference I Python O(n) O(1) Easy array, SLIDING “GAP” + RUNNING MIN / MAX INDEX, new imported
2905 Find Indices With Index and Value Difference II Python O(n) O(1) Medium array, SLIDING “GAP” + RUNNING MIN / MAX INDEX, new imported
3000 Maximum Area of Longest Diagonal Rectangle Python O(n) O(1) Easy array, GREEDY ONE PASS ON (DIAGONAL^2, AREA), new imported
3009 Maximum Number of Intersections on the Chart Python O(n log n) O(n) Hard array, 🔒, EACH SEGMENT IS AN INTERVAL OF y-VALUES — SWEEP FOR THE MAX OVERLAP, new imported
3010 Divide an Array Into Subarrays With Minimum Cost I Python O(n log n) O(n) Easy array, THE FIRST COST IS FORCED — PICK THE TWO CHEAPEST STARTS FOR THE REST, new imported
3015 Count the Number of Houses at a Certain Distance I Python O(n^2) O(n) Medium array, n <= 100 — JUST BFS FROM EVERY HOUSE, new imported
3017 Count the Number of Houses at a Certain Distance II Python O(n) O(n) Hard array, THE GRAPH IS A CYCLE WITH TWO TAILS — EACH SOURCE ADDS O(1) RANGES, new imported
3028 Ant on the Boundary Python O(n) O(1) Easy array, RUNNING PREFIX SUM — COUNT HOW OFTEN IT HITS 0, new imported
3030 Find the Grid of Region Average Python O(m * n) O(m * n) Medium array, TEST EVERY 3x3 WINDOW, THEN AVERAGE THE PER-REGION AVERAGES, new imported
3033 Modify the Matrix Python O(m * n) O(m * n) Easy array, ONE PASS FOR THE COLUMN MAXIMA, ONE PASS TO SUBSTITUTE, new imported
3038 Maximum Number of Operations With the Same Score I Python O(n) O(1) Easy array, THE SCORE IS FIXED BY THE FIRST PAIR — THEN JUST WALK FORWARD, new imported
3065 Minimum Operations to Exceed Threshold Value I Python O(n) O(1) Easy array, THE OPERATION ALWAYS TAKES THE SMALLEST — SO IT JUST DELETES EVERY VALUE BELOW k, new imported
3069 Distribute Elements Into Two Arrays I Python O(n) O(n) Easy array, DIRECT SIMULATION — ONLY THE TWO TAIL VALUES DECIDE EACH STEP, new imported
3070 Count Submatrices with Top-Left Element and Sum Less Than k Python O(m * n) O(m * n) Medium array, A SUBMATRIX CONTAINING (0,0) IS A PREFIX RECTANGLE, new imported
3071 Minimum Operations to Write the Letter Y on a Grid Python O(n^2) O(1) Medium array, ONLY 6 TARGET COLOURINGS EXIST — COUNT ONCE, THEN SCORE EACH, new imported
3079 Find the Sum of Encrypted Integers Python O(n * digits) O(digits) Easy array, REPEAT THE LARGEST DIGIT AS MANY TIMES AS THERE ARE DIGITS, new imported
3096 Minimum Levels to Gain More Points Python O(n) O(1) Medium array, SCORES ARE PREFIX SUMS OF +1 / -1 — SCAN FOR THE FIRST SPLIT THAT WINS, new imported
3105 Longest Strictly Increasing or Strictly Decreasing Subarray Python O(n) O(1) Easy array, TWO RUNNING STREAK COUNTERS, ONE PER DIRECTION, new imported
3127 Make a Square with the Same Color Python O(1) O(1) Easy array, A 2x2 BLOCK IS FIXABLE IFF IT IS NOT ALREADY 2-2 SPLIT, new imported
3131 Find the Integer Added to Array I Python O(n) O(1) Easy array, A CONSTANT SHIFT MOVES THE MINIMUM BY EXACTLY THAT CONSTANT, new imported
3142 Check if Grid Satisfies Conditions Python O(m * n) O(1) Easy array, TWO LOCAL CHECKS PER CELL, GUARDED BY THE BOUNDS, new imported
3147 Taking Maximum Energy From the Mystic Dungeon Python O(n) O(1) beyond the copy Medium array, SUFFIX SUMS ALONG EACH JUMP CHAIN, BUILT FROM THE BACK, new imported
3151 Special Array I Python O(n) O(1) Easy array, NEIGHBOURS MUST DISAGREE IN THE LOWEST BIT, new imported
3152 Special Array II Python O(n + q) O(n) Medium array, PREFIX-COUNT THE BAD ADJACENT PAIRS, THEN EACH QUERY IS O(1), new imported
3153 Sum of Digit Differences of All Pairs Python O(n * digits) O(1) Medium array, HANDLE EACH DIGIT POSITION SEPARATELY AND COUNT THE AGREEING PAIRS, new imported
3159 Find Occurrences of an Element in an Array Python O(n + q) O(n) Medium array, COLLECT THE POSITIONS OF x ONCE, THEN EVERY QUERY IS A LOOKUP, new imported
3173 Bitwise OR of Adjacent Elements Python O(n) O(n) Easy array, 🔒, ZIP THE ARRAY WITH ITS OWN TAIL, new imported
3187 Peaks in Array Python O((n + q) log n) O(n) Hard array, A FENWICK TREE OVER “IS THIS INDEX A PEAK”, REPAIRED LOCALLY ON UPDATES, new imported
3224 Minimum Array Changes to Make Differences Equal Python O(n + k) O(k) Medium array, SCORE EVERY CANDIDATE X AT ONCE WITH A DIFFERENCE ARRAY, new imported
3285 Find Indices of Stable Mountains Python O(n) O(n) Easy array, A DIRECT READING — LOOK ONE STEP BACK, new imported
3300 Minimum Element After Replacement With Digit Sum Python O(n * digits) O(1) Easy array, DIGIT SUM VIA THE DECIMAL STRING, THEN TAKE THE MINIMUM, new imported
3330 Find the Original Typed String I Python O(n) O(1) Easy array, AT MOST ONE RUN MAY HAVE BEEN OVER-TYPED, AND ONLY BY SOME AMOUNT, new imported
3334 Find the Maximum Factor Score of Array Python O(n log max) O(n) Medium array, PREFIX AND SUFFIX GCD / LCM SO EACH REMOVAL IS AN O(1) COMBINE, new imported
3349 Adjacent Increasing Subarrays Detection I Python O(n * k) O(1) Easy array, TEST EVERY ANCHOR — THE SECOND BLOCK STARTS EXACTLY k LATER, new imported
3350 Adjacent Increasing Subarrays Detection II Python O(n) O(1) Medium array, SPLIT INTO MAXIMAL RISING RUNS — THE ANSWER LIVES INSIDE OR ACROSS ONE BOUNDARY, new imported
3354 Make Array Elements Equal to Zero Python O(n * (n + sum(nums))) O(n) Easy array, THE INPUT IS SMALL — REPLAY THE WHOLE PROCESS FOR EACH START, new imported
3355 Zero Array Transformation I Python O(n + q) O(n) Medium array, THE SUBSETS ARE FREE, SO ONLY THE PER-INDEX COVERAGE MATTERS, new imported
3379 Transformed Array Python O(n) O(n) Easy array, PYTHON’S MODULO ALREADY WRAPS IN BOTH DIRECTIONS, new imported
3380 Maximum Area Rectangle With Point Constraints I Python O(n^5) worst case with n = 10 O(n) Medium array, ONLY 10 POINTS — TRY EVERY (x1, x2) x (y1, y2) BOX, new imported
3382 Maximum Area Rectangle With Point Constraints II Python O(n log n) O(n) Hard array, SWEEP BY x, PAIRING VERTICALLY ADJACENT POINTS, COUNTING WITH A BIT, new imported
3386 Button with Longest Push Time Python O(n) O(1) Easy array, ONE PASS ON THE GAPS BETWEEN CONSECUTIVE PRESSES, new imported
3392 Count Subarrays of Length Three With a Condition Python O(n) O(1) Easy array, SLIDE A WINDOW OF 3 AND TEST THE CONDITION WITHOUT DIVIDING, new imported
3400 Maximum Number of Matching Indices After Right Shifts Python O(n^2) O(n) Medium array, 🔒, TRY EVERY ROTATION, COMPARE WITH A DOUBLED ARRAY, new imported
3417 Zigzag Grid Traversal With Skip Python O(m * n) O(m * n) Easy array, LINEARISE THE BOUSTROPHEDON ORDER, THEN TAKE EVERY OTHER CELL, new imported
3423 Maximum Difference Between Adjacent Elements in a Circular Array Python O(n) O(1) Easy array, SCAN THE PAIRS, WRAPPING THE INDEX WITH MODULO, new imported
3427 Sum of Variable Length Subarrays Python O(n) O(n) Easy array, PREFIX SUMS, ONE RANGE LOOKUP PER INDEX, new imported
3432 Count Partitions with Even Sum Difference Python O(n) O(1) Easy array, THE PARITY OF THE DIFFERENCE DOES NOT DEPEND ON WHERE YOU CUT, new imported
3440 Reschedule Meetings for Maximum Free Time II Python O(n) O(n) Medium array, ONE MEETING MAY TELEPORT — ASK WHETHER SOME OTHER GAP CAN HOST IT, new imported
3446 Sort Matrix by Diagonals Python O(n^2 log n) O(n^2) Medium array, GROUP CELLS BY i - j, SORT EACH DIAGONAL IN ITS OWN DIRECTION, new imported
3502 Minimum Cost to Reach Every Position Python O(n) O(1) extra Easy array, RUNNING PREFIX MINIMUM, new imported
3514 Number of Unique XOR Triplets II Python O(n^2 + V^2) with V = 2048 O(V) Medium array, PAIR XORS FIRST, THEN ONE MORE XOR PASS, new imported
3531 Count Covered Buildings Python O(m) O(m) Medium array, ONLY THE EXTREMES OF EACH ROW AND COLUMN CAN FAIL, new imported
3537 Fill a Special Grid Python O(4^n) O(4^n) Medium array, BUILD BY DOUBLING – THE FOUR QUADRANTS ARE THE SAME GRID, SHIFTED, new imported
3540 Minimum Time to Visit All Houses Python O(n + q) O(n) Medium array, 🔒, EACH HOP IS INDEPENDENT – TWO PREFIX SUMS AROUND THE CIRCLE, new imported
3546 Equal Sum Grid Partition I Python O(m * n) O(n) Medium array, A CUT IS JUST A PREFIX – CHECK EVERY PREFIX SUM AGAINST HALF THE TOTAL, new imported
3548 Equal Sum Grid Partition II Python O(m * n) O(m * n) Hard array, SWEEP EVERY CUT, THEN ASK WHETHER THE EXCESS SITS IN A REMOVABLE CELL, new imported
3549 Multiply Two Polynomials Python O(N log N) via the big-int multiply O(N) Hard array, 🔒, KRONECKER SUBSTITUTION – LET PYTHON’S BIG-INT MULTIPLY DO THE FFT, new imported
3550 Smallest Index With Digit Sum Equal to Index Python O(n * d) O(1) Easy array, SCAN LEFT TO RIGHT AND STOP AT THE FIRST HIT, new imported
3569 Maximize Count of Distinct Primes After Split Python O((n + q) * log n + V log log V) O(n + V) Hard array, REWRITE THE SPLIT VALUE AS “TOTAL PRIMES + INTERVAL COVERAGE”, new imported
3637 Trionic Array I Python O(n) O(1) Easy array, WALK THE THREE MONOTONE RUNS GREEDILY, new imported
3643 Flip Square Submatrix Vertically Python O(k^2) O(1) Easy array, SWAP MIRRORED ROW SLICES IN PLACE, new imported
3653 XOR After Range Multiplication Queries I Python O(q * n) O(1) Medium array, DIRECT SIMULATION — THE ARITHMETIC PROGRESSION IS SHORT ENOUGH, new imported
3655 XOR After Range Multiplication Queries II Python O((q + n) * sqrt(n)) O(n + q) Hard array, HEAVY/LIGHT SPLIT ON THE STRIDE, WITH A MULTIPLICATIVE DIFFERENCE, new imported
3674 Minimum Operations to Equalize Array Python O(n) O(1) Easy array, ONE WHOLE-ARRAY OPERATION ALWAYS SUFFICES, new imported
3683 Earliest Time to Finish One Task Python O(n) O(1) Easy array, EACH TASK’S FINISH TIME IS INDEPENDENT – TAKE THE MINIMUM, new imported
3687 Library Late Fee Calculator Python O(n) O(1) Easy array, 🔒, PER-BOOK PIECEWISE FEE, SUMMED, new imported

Backtracking

# Title Solution Time Space Difficulty Note Status
0291 Word Pattern II Python, Java O(n^m) O(m + n) Medium backtracking, 🔒, LC 290, backtracking with a bijection map, good trick, new, amazon, fb, uber imported
0488 Zuma Game Python, Java O(s * h * b^2) O(s * (b + h)) Hard backtracking, backtracking + memo over (board, hand), complex, new, string, dp, stack imported
0679 24 Game Python, Java O(1) O(1) Hard backtracking, backtrack over every pair and operator, float epsilon compare, good trick, new, google, amazon, apple, microsoft, uber imported
0996 Number of Squareful Arrays Python, Java O(n!) O(n) Hard backtracking, permutations with perfect-square adjacency pruning, dedupe same-layer, new, google, apple imported
1096 Brace Expansion II Python O(L * W) O(W) Hard backtracking, STACK PARSER (union list + product set per nesting level), new, google, microsoft imported
1240 Tiling a Rectangle with the Fewest Squares Python exponential (pruned) ; n, m <= 13 O(n * m), recursion depth Hard backtracking, BACKTRACKING + BITMASK (fill the first empty cell, scan row by row), new, google imported
1255 Maximum Score Words Formed by Letters Python O(2^n * L) O(n + L) n = len(words), L = total word length Hard backtracking, BACKTRACKING (take / skip each word, undo the letter spend on return), new, google, amazon imported
1258 Synonymous Sentences Python O(m ^ w * w) O(n + w), n = number of distinct synonym words Medium backtracking, UNION FIND + BACKTRACK (DFS), new, google, amazon imported
1307 Verbal Arithmetic Puzzle Python O(10!) worst case, heavily pruned in practice O(1), at most 10 distinct letters Hard backtracking, coefficient backtracking, new imported
1379 Find a Corresponding Node of a Binary Tree in a Clone of That Tree Python O(n) O(h), h = tree height (recursion stack) Easy backtracking, walk BOTH trees in lock step (DFS), new, amazon, fb imported
1593 Split a String Into the Max Number of Unique Substrings Python O(2^n * n) O(n^2) Medium backtracking, BACKTRACKING (n <= 16, try every cut with a “used pieces” set), new, google, microsoft imported
1659 Maximize Grid Happiness Python O(m*n * 3^n * I * E * 3) O(m*n * 3^n * I * E) Hard backtracking, PROFILE (BROKEN-PROFILE) DP + MEMO, cell by cell, base-3 mask, new imported
1718 Construct the Lexicographically Largest Valid Sequence Python O(n!) worst case (heavily pruned; n <= 20) O(n) Medium backtracking, BACKTRACKING, TRY BIG VALUES FIRST (first success = the answer), new, fb imported
1723 Find Minimum Time to Finish All Jobs Python O(k^n) worst case, heavily pruned (n <= 12) O(n + k) Hard backtracking, BACKTRACKING WITH BRANCH-AND-BOUND PRUNING, new, amazon imported
1849 Splitting a String Into Descending Consecutive Values Python O(n^2) O(n) Medium backtracking, BACKTRACKING – only the FIRST piece really branches, new imported
1999 Smallest Greater Multiple Made of Two Digits Python O(2^L) with L <= 10 digits before the 2^31 cutoff O(2^L) Medium backtracking, 🔒, BFS OVER THE DIGIT TREE (generates candidates in increasing order), new imported
2014 Longest Subsequence Repeated k Times Python O(26^L * n) with L <= 7 but the k-repetition prune keeps it tiny O(number of surviving candidates) Hard backtracking, BFS OVER CANDIDATES (grow level by level, prune with a greedy check), new, fb imported
2056 Number of Valid Move Combinations On Chessboard Python O((8 * 8)^n) with n <= 4 O(n * 81) Hard backtracking, BACKTRACKING PIECE BY PIECE, RECORDING EACH PIECE’S TIMELINE, new, fb imported
2094 Finding 3-Digit Even Numbers Python O(1) (bounded by 450 candidates) O(1) Easy backtracking, ENUMERATE ALL 900 THREE-DIGIT EVEN NUMBERS, CHECK MULTISET SUPPLY, new imported
2443 Sum of Number and Its Reverse Python O(num * d), d = number of digits O(d) Medium backtracking, ENUMERATION (the candidate k is bounded, so just scan it), new imported
2664 The Knight’s Tour Python O(8^(m*n)) worst case (tiny in practice) O(m*n) Medium backtracking, 🔒, BACKTRACKING (DFS) OVER THE 8 KNIGHT MOVES, new imported
2698 Find the Punishment Number of an Integer Python O(n * 2^d) with d = digits of n^2 (<= 7) O(d) Medium backtracking, BACKTRACKING OVER THE SPLIT POINTS OF str(i * i), new imported
2741 Special Permutations Python O(n^2 * 2^n) O(n * 2^n) Medium backtracking, BACKTRACKING COMPRESSED INTO BITMASK DP (STATE COMPRESSION), new imported
3211 Generate Binary Strings Without Adjacent Zeros Python O(n * number of valid strings) O(n) recursion Medium backtracking, BACKTRACK, REFUSING TO PLACE A ‘0’ AFTER A ‘0’, new imported
3437 Permutations III Python O(n * number of alternating permutations) O(n) Medium backtracking, 🔒, BACKTRACKING THAT ONLY EVER OFFERS THE OPPOSITE PARITY, new imported
3565 Sequential Grid Path Cover Python O(m * n * 3^(m * n)) worst case O(m * n) Medium backtracking, 🔒, BACKTRACKING WITH THE “NEXT WANTED LABEL” AS PART OF THE STATE, new imported
3669 Balanced K-Factor Decomposition Python O(d(n)^(k-1) * sqrt(n)) in the worst case, tiny in practice O(k) Medium backtracking, DFS OVER DIVISORS IN NON-DECREASING ORDER, new imported

Binary Heap

# Title Solution Time Space Difficulty Note Status
0480 Sliding Window Median Python, Java O(n * k) O(k) Hard heap, two heaps with lazy deletion, or SortedList, LC 295, LC 239, good trick, new, google, amazon, fb, apple imported
0632 Smallest Range Covering Elements from K Lists Python, Java O(nlogk) O(k) Hard heap, min-heap over k list pointers while tracking the current max, LC 23, good trick, new, google, amazon, fb, apple, microsoft imported
0857 Minimum Cost to Hire K Workers Python, Java O(nlogn) O(n) Hard heap, sort by wage/quality ratio + max-heap of quality, greedy, good trick, new, google imported
1439 Find the Kth Smallest Sum of a Matrix With Sorted Rows Python O(m * k * n log(k * n)) O(k * n) Hard heap, ROW BY ROW MERGE, KEEP ONLY THE k SMALLEST, new, fb imported
1606 Find Servers That Handled Most Number of Requests Python O((n + k) log k) O(k) Hard heap, MIN-HEAP (busy servers by finish time) + BIT over free servers, new, apple imported
1792 Maximum Average Pass Ratio Python O((n + k) log n) O(n) Medium heap, MAX HEAP ON THE MARGINAL GAIN (the gain is strictly decreasing per class), new, amazon imported
1962 Remove Stones to Minimize the Total Python O(n + k*log n) O(n) Medium heap, GREEDY + MAX HEAP, new imported
2054 Two Best Non-Overlapping Events Python O(n log n) O(n) Medium heap, SORT BY START + SUFFIX MAX + BINARY SEARCH, new imported
2163 Minimum Difference in Sums After Removal of Elements Python O(n log n) O(n) Hard heap, SPLIT POINT + TWO HEAPS — MINIMISE THE LEFT SUM, MAXIMISE THE RIGHT, new imported
2208 Minimum Operations to Halve Array Sum Python O(n log n) O(n) Medium heap, ALWAYS HALVE THE CURRENT LARGEST — MAX-HEAP, new imported
2386 Find the K-Sum of an Array Python O(n log n + k log k) O(n + k) Hard heap, REDUCE TO “k SMALLEST SUBSET SUMS OF THE ABSOLUTE VALUES”, new imported
2462 Total Cost to Hire K Workers Python O((k + candidates) log candidates) O(candidates) Medium heap, TWO MIN-HEAPS, ONE PER END, REFILLED FROM THE SHRINKING MIDDLE, new imported
2519 Count the Number of K-Big Indices Python O(n * log k) O(n) Hard heap, 🔒, TWO SIZE-K MAX HEAPS (keep only the k smallest values on each side), new imported
2530 Maximal Score After Applying K Operations Python O(n + k * log n) O(n) Medium heap, GREEDY + MAX HEAP, new imported
2558 Take Gifts From the Richest Pile Python O(n + k log n) O(n) Easy heap, MAX HEAP (SIMULATION), new imported
2818 Apply Operations to Maximize Score Python O(V log log V + n log n) O(V + n) # V = max(nums) <= 10^5 Hard heap, PRIME SCORE (LINEAR SIEVE) + MONOTONIC STACK “DOMINANCE RANGE”, new imported
3066 Minimum Operations to Exceed Threshold Value II Python O(n log n) O(n) Medium heap, MIN-HEAP — THE OPERATION IS FORCED, SO JUST SIMULATE IT, new imported
3080 Mark Elements on Array by Performing Queries Python O((n + sum of k) log n) O(n) Medium heap, MIN-HEAP BY (VALUE, INDEX) + LAZY SKIPPING OF ALREADY-MARKED ENTRIES, new imported
3256 Maximum Value Sum by Placing Three Rooks I Python O(m * n + m^3) O(m) Hard heap, ONLY EACH ROW’S TOP THREE CELLS CAN EVER BE USED, new imported
3257 Maximum Value Sum by Placing Three Rooks II Python O(m * n log n) O(m) Hard heap, FIX THE MIDDLE ROW, THEN TAKE THE BEST ROW ABOVE AND BELOW, new imported
3275 K-th Nearest Obstacle Queries Python O(q log k) O(k) Medium heap, A BOUNDED MAX-HEAP HOLDING THE k CLOSEST DISTANCES, new imported
3684 Maximize Sum of At Most K Distinct Elements Python O(n log n) O(n) Easy heap, DEDUPE FIRST, THEN GREEDILY TAKE THE k LARGEST DISTINCT VALUES, new imported

Binary Search

# Title Solution Time Space Difficulty Note Status
0302 Smallest Rectangle Enclosing Black Pixels Python, Java O(mlogn + nlogm) O(1) Hard binary search, 🔒, binary search each border of the black region, LC 200, good trick, new, google imported
0354 Russian Doll Envelopes Python, Java O(nlogn) O(n) Hard binary search, sort by width asc / height desc then LIS, LC 300, good trick, new, google, amazon, apple, microsoft, uber imported
0668 Kth Smallest Number in Multiplication Table Python, Java O(mlog(m * n)) O(1) Hard binary search, binary search on the answer, count values <= x, good trick, new, google, amazon, uber imported
0702 Search in a Sorted Array of Unknown Size Python, Java O(logM) O(1) Medium binary search, 🔒, exponential search then binary search, ArrayReader API, new, google, amazon, fb, microsoft imported
0719 Find K-th Smallest Pair Distance Python, Java O(nlogn + nlogW) O(1) Hard binary search, binary search on the distance + two pointers to count pairs, good trick, new, google, amazon, fb imported
0786 K-th Smallest Prime Fraction Python, Java O(n + klogn) O(n) Medium binary search, binary search on the fraction value, or a heap of k candidates, new, google imported
0793 Preimage Size of Factorial Zeroes Function Python, Java O((logk)^2) O(1) Hard binary search, binary search on the trailing-zero count, LC 172, new, amazon imported
0878 Nth Magical Number Python, Java O(log(n * min(a, b))) O(1) Hard binary search, binary search + inclusion-exclusion with lcm(a, b), math, new, amazon imported
1044 Longest Duplicate Substring Python O(n log n) O(n) Hard binary search, BINARY SEARCH ON LENGTH + RABIN-KARP (rolling hash), new, google, amazon, fb, apple, microsoft, uber imported
1062 Longest Repeating Substring Python O(n^2 log n) O(n^2) Medium binary search, 🔒, BINARY SEARCH on the answer + HASH SET, new, google, amazon, fb imported
1064 Fixed Point Python O(log n) O(1) Easy binary search, 🔒, BINARY SEARCH (find first index with arr[i] - i >= 0), new, uber imported
1201 Ugly Number III Python O(log(2 * 10^9)) O(1) Medium binary search, BINARY SEARCH on ANSWER + INCLUSION-EXCLUSION, new, google, amazon imported
1228 Missing Number In Arithmetic Progression Python O(log n) O(1) Easy binary search, BINARY SEARCH ON THE “STILL IN PLACE” PREDICATE, new, fb imported
1274 Number of Ships in a Rectangle Python O(s * log(max(m, n))), s = number of ships (<= 10) O(log(max(m, n))), recursion depth Hard binary search, DIVIDE AND CONQUER (quad tree style), new imported
1287 Element Appearing More Than 25% In Sorted Array Python O(n) O(1) Easy binary search, SORTED ARRAY property + fixed offset check, new, google, fb imported
1385 Find the Distance Value Between Two Arrays Python O((m + n) log n) O(n), sorting Easy binary search, sort arr2 + binary search, new, uber imported
1533 Find the Index of the Large Integer Python O(log n) calls O(1) Medium binary search, 🔒, BINARY SEARCH ON THE INTERACTIVE COMPARATOR, new, amazon imported
1539 Kth Missing Positive Number Python O(log n) O(1) Easy binary search, BINARY SEARCH ON “HOW MANY ARE MISSING BEFORE INDEX i”, new, google, amazon, fb, apple, microsoft imported
1618 Maximum Font to Fit a Sentence in a Screen Python O(len(text) + 26 * log(len(fonts))) O(26) Medium binary search, 🔒, BINARY SEARCH ON ANSWER (fit() is monotone over fonts), new, google imported
1671 Minimum Number of Removals to Make Mountain Array Python O(n log n) O(n) Hard binary search, BIDIRECTIONAL LIS + BINARY SEARCH (keep the longest mountain, drop the rest), new imported
1713 Minimum Operations to Make a Subsequence Python O(n * log m) O(m + n) Hard binary search, LCS -> LIS (target is DISTINCT, so map values to indices) + BINARY SEARCH, new, google imported
1802 Maximum Value at a Given Index in a Bounded Array Python O(log(maxSum)) O(1) Medium binary search, BINARY SEARCH ON THE ANSWER (feasibility is monotone), new imported
1818 Minimum Absolute Sum Difference Python O(n log n) O(n) Medium binary search, SORT + BINARY SEARCH FOR THE BEST SINGLE SWAP (maximise the saving), new, uber imported
1870 Minimum Speed to Arrive on Time Python O(n * log(10^7)) O(1) Medium binary search, BINARY SEARCH ON THE ANSWER (total time is monotone in speed), new, google imported
1901 Find a Peak Element II Python O(n log m) O(1) Medium binary search, BINARY SEARCH ON ROWS (the row max is a peak or points uphill), new, fb, microsoft imported
1918 Kth Smallest Subarray Sum Python O(n * log(S)), S = sum(nums) O(1) Medium binary search, 🔒, BINARY SEARCH ON THE ANSWER + SLIDING WINDOW COUNT, new, google imported
1964 Find the Longest Valid Obstacle Course at Each Position Python O(n log n) O(n) Hard binary search, LIS (non-decreasing) via PATIENCE / BINARY SEARCH ON TAILS, new imported
2064 Minimized Maximum of Products Distributed to Any Store Python O(m log(max q)) O(1) Medium binary search, BINARY SEARCH ON THE ANSWER (minimise the maximum), new imported
2111 Minimum Operations to Make the Array K-Increasing Python O(n log n) O(n) Hard binary search, SPLIT INTO k INDEPENDENT SUBSEQUENCES, KEEP THE LONGEST, new, amazon imported
2137 Pour Water Between Buckets to Make Water Levels Equal Python O(n * 100) O(1) Medium binary search, 🔒, BINARY SEARCH ON THE FINAL WATER LEVEL (a real number), new imported
2187 Minimum Time to Complete Trips Python O(n log(min(time) * totalTrips)) O(1) Medium binary search, BINARY SEARCH ON THE ANSWER (a time, not an index), new imported
2226 Maximum Candies Allocated to K Children Python O(n * log(max(candies))) O(1) Medium binary search, BINARY SEARCH ON THE ANSWER (monotone feasibility), new imported
2250 Count Number of Rectangles Containing Each Point Python O(R log R + P * 100 * log R) O® Medium binary search, HEIGHTS ONLY GO UP TO 100 — BUCKET BY HEIGHT, BINARY SEARCH LENGTHS, new imported
2300 Successful Pairs of Spells and Potions Python O((n + m) log m) O(m) Medium binary search, SORT THE POTIONS ONCE, BINARY SEARCH THE THRESHOLD PER SPELL, new imported
2333 Minimum Sum of Squared Difference Python O(n log(max diff)) O(n) Medium binary search, ONLY abs(nums1[i] - nums2[i]) MATTERS — BINARY SEARCH THE CAP, new imported
2387 Median of a Row Wise Sorted Matrix Python O(m log n log(max value)) O(1) Medium binary search, 🔒, BINARY SEARCH ON THE VALUE, COUNTING WITH ONE BISECT PER ROW, new imported
2389 Longest Subsequence With Limited Sum Python O(n log n + m log n) O(n) Easy binary search, ORDER DOES NOT MATTER — SORT ASCENDING AND PREFIX-SUM, new imported
2448 Minimum Cost to Make Array Equal Python O(n log n) O(n) Hard binary search, WEIGHTED MEDIAN (f(x) = sum cost[i] * |nums[i] - x| is convex piecewise linear), new imported
2476 Closest Nodes Queries in a Binary Search Tree Python O(n + q * log n) O(n) Medium binary search, IN-ORDER TRAVERSAL -> SORTED ARRAY + BINARY SEARCH, new imported
2513 Minimize the Maximum of Two Arrays Python O(log(MAX) + log(min(d1, d2))) O(1) Medium binary search, BINARY SEARCH ON THE ANSWER (+ inclusion-exclusion via LCM), new imported
2517 Maximum Tastiness of Candy Basket Python O(n * log n + n * log(maxPrice)) O(1) beyond the sort Medium binary search, BINARY SEARCH ON THE ANSWER + GREEDY FEASIBILITY CHECK, new imported
2528 Maximize the Minimum Powered City Python O(n * log(sum(stations) + k)) O(n) Hard binary search, BINARY SEARCH ON ANSWER + DIFFERENCE ARRAY + GREEDY (sweep left->right), new imported
2529 Maximum Count of Positive Integer and Negative Integer Python O(log n) O(1) Easy binary search, BINARY SEARCH ON THE SORTED ARRAY (the follow-up’s O(log n)), new imported
2557 Maximum Number of Integers to Choose From a Range II Python O(m log m + m log n) O(m) (m = len(banned)) Medium binary search, 🔒, GREEDY (SMALLEST FIRST) + BINARY SEARCH ON EACH FREE GAP, new imported
2602 Minimum Operations to Make All Array Elements Equal Python O((n + m) * log n) O(n) Medium binary search, SORT + PREFIX SUM + BINARY SEARCH, new imported
2702 Minimum Operations to Make Numbers Non-positive Python O(n * log(max(nums))) O(1) Hard binary search, 🔒, BINARY SEARCH ON THE ANSWER, new imported
3048 Earliest Second to Mark Indices I Python O(m log m) O(n + m) Medium binary search, BINARY SEARCH THE DEADLINE, GREEDY CHECK WITH “MARK AT THE LAST CHANCE”, new imported
3049 Earliest Second to Mark Indices II Python O(m log m log m) O(n + m) Hard binary search, BINARY SEARCH THE DEADLINE + A HEAP GREEDY FOR “WHICH INDICES TO ZERO”, new imported
3104 Find Longest Self-Contained Substring Python O(26 * n) O(1) Hard binary search, 🔒, THE START MUST BE A FIRST OCCURRENCE — SO THERE ARE AT MOST 26 STARTS, new imported
3116 Kth Smallest Amount With Single Denomination Combination Python O(2^n * log(min(coins) * k)) O(2^n) Hard binary search, BINARY SEARCH THE AMOUNT, COUNT WITH INCLUSION-EXCLUSION, new imported
3134 Find the Median of the Uniqueness Array Python O(n log n) O(n) Hard binary search, BINARY SEARCH THE MEDIAN VALUE, COUNT WITH A SLIDING WINDOW, new imported
3135 Equalize Strings by Adding or Removing Characters at Ends Python O(n * m) O(m) Medium binary search, 🔒, ONLY A COMMON SUBSTRING CAN SURVIVE — SO MAXIMISE ITS LENGTH, new imported
3145 Find Products of Elements of Big Array Python O(q * log^2(max index)) O(1) Hard binary search, EVERY ENTRY IS A POWER OF TWO — SO WORK WITH EXPONENT SUMS, new imported
3231 Minimum Number of Increasing Subsequence to Be Removed Python O(n log n) O(n) Hard binary search, 🔒, DILWORTH — THE ANSWER IS THE LONGEST NON-INCREASING SUBSEQUENCE, new imported
3233 Find the Count of Numbers Which Are Not Special Python O(sqrt® log log sqrt®) O(sqrt®) Medium binary search, “EXACTLY TWO PROPER DIVISORS” MEANS x IS THE SQUARE OF A PRIME, new imported
3281 Maximize Score of Numbers in Ranges Python O(n log n + n log(range)) O(n) Medium binary search, BINARY SEARCH THE GAP, PLACE GREEDILY LEFT TO RIGHT, new imported
3288 Length of the Longest Increasing Path Python O(n log n) O(n) Hard binary search, TWO STRICT LIS RUNS — ONE BEFORE THE PIVOT, ONE AFTER, new imported
3296 Minimum Number of Seconds to Make Mountain Height Zero Python O(n log(max T)) O(1) Medium binary search, BINARY SEARCH THE FINISH TIME — THE WORKERS ARE INDEPENDENT, new imported
3356 Zero Array Transformation II Python O((n + q) log q) O(n) Medium binary search, BINARY SEARCH ON THE PREFIX LENGTH, DIFFERENCE ARRAY FOR THE CHECK, new imported
3357 Minimize the Maximum Adjacent Element Difference Python O(n log(max value)) O(n) Hard binary search, BINARY SEARCH THE ANSWER, GREEDY FEASIBILITY WITH TWO CANDIDATE VALUES, new imported
3398 Smallest Substring With Identical Characters I Python O(n^2) worst case O(1) Hard binary search, THE ANSWER IS MONOTONE — TEST EACH CANDIDATE LENGTH DIRECTLY, new imported
3399 Smallest Substring With Identical Characters II Python O(n log n) O(1) Hard binary search, BINARY SEARCH THE ANSWER, GREEDY FEASIBILITY CHECK, new imported
3520 Minimum Threshold for Inversion Pairs Count Python O(n * log n * log(maxV)) O(n) Medium binary search, 🔒, BINARY SEARCH ON THE THRESHOLD + FENWICK COUNT OF QUALIFYING PAIRS, new imported
3605 Minimum Stability Factor of Array Python O(n * log(max(nums)) + n * log(n)) O(n) Hard binary search, BINARY SEARCH THE ANSWER + GREEDY INTERVAL STABBING WITH GCD RUNS, new imported

Binary Search Tree

# Title Solution Time Space Difficulty Note Status
0352 Data Stream as Disjoint Intervals Python, Java addNum: O(n), getIntervals: O(n) O(n) Hard BST, sorted interval list with binary search insert, TreeMap, LC 228, LC 715, new, hash table, union find, google, amazon, microsoft, linkedin imported
1373 Maximum Sum BST in Binary Tree Python O(n) O(h) h = tree height Hard binary search tree, POST-ORDER DFS returning (is_bst, subtree_min, subtree_max, subtree_sum), new, amazon, fb, apple imported
1932 Merge BSTs to Create Single BST Python O(n) O(n) Hard binary search tree, FIND THE UNIQUE OVERALL ROOT, THEN SPLICE + VALIDATE IN ONE DFS, new, amazon imported
2426 Number of Pairs Satisfying Inequality Python O(n log V) O(V) Hard binary search tree, REARRANGE INTO ONE ARRAY, THEN COUNT WITH A FENWICK TREE, new imported
2689 Extract Kth Character From The Rope Tree Python O(h) where h is the tree height O(1) Easy binary search tree, 🔒, BINARY-SEARCH STYLE DESCENT (never build the whole string), new imported
2817 Minimum Absolute Difference Between Elements With Constraint Python O(n * log n) O(n) Medium binary search tree, SLIDING “ORDERED SET” OF ELIGIBLE PARTNERS (BST-STYLE PREDECESSOR /, new imported
3072 Distribute Elements Into Two Arrays II Python O(n log n) O(n) Hard binary search tree, TWO FENWICK TREES OVER THE COMPRESSED VALUES, new imported
3073 Maximum Increasing Triplet Value Python O(n log n) O(n) Medium binary search tree, 🔒, FIX THE MIDDLE, THEN WANT THE BIGGEST VALID LEFT AND RIGHT, new imported
3161 Block Placement Queries Python O((n + maxX) log maxX) O(n + maxX) Hard binary search tree, RUN THE QUERIES BACKWARDS SO INSERTIONS BECOME DELETIONS, new imported
3165 Maximum Sum of Subsequence With Non-adjacent Elements Python O((n + q) log n) O(n) Hard binary search tree, SEGMENT TREE WHOSE NODES CARRY A 2x2 “BOUNDARY” TABLE, new imported
3526 Range XOR Queries with Subarray Reversals Python O(n + q * log n) expected O(n) Hard binary search tree, 🔒, IMPLICIT TREAP (BALANCED BST KEYED BY POSITION) WITH A LAZY REVERSE FLAG, new imported

Bit Manipulation

# Title Solution Time Space Difficulty Note Status
0411 Minimum Unique Word Abbreviation Python, Java O(2^m * n) O(n) Hard bit manipulation, 🔒, bit-mask each word then enumerate abbreviation masks, LC 320, LC 408, new, google imported
0476 Number Complement Python, Java O(1) O(1) Easy bit manipulation, flip the bits below the highest set bit, LC 190, basic, new, apple imported
1310 XOR Queries of a Subarray Python O(n + m) O(n) Medium bit manipulation, prefix XOR, new, amazon imported
1318 Minimum Flips to Make a OR b Equal to c Python O(32) O(1) Medium bit manipulation, BIT MANIPULATION (bits are independent -> decide each one alone), new imported
1558 Minimum Numbers of Function Calls to Make Target Array Python O(n * log(max)) O(1) Medium bit manipulation, BIT MANIPULATION (work backwards : halve everything, decrement odds), new, amazon imported
1707 Maximum XOR With an Element From Array Python O(nlog n + qlog q + (n + q)*30) O(n * 30) Hard bit manipulation, OFFLINE QUERIES + BINARY TRIE (sort by m, grow the trie monotonically), new, google imported
1720 Decode XORed Array Python O(n) O(n) for the output Easy bit manipulation, BIT MANIPULATION (XOR is its own inverse), new imported
1734 Decode XORed Permutation Python O(n) O(n) for the output Medium bit manipulation, BIT MANIPULATION - recover ONE element first, then unroll the chain, new, amazon imported
1829 Maximum XOR for Each Query Python O(n) O(1) extra (O(n) output) Medium bit manipulation, RUNNING PREFIX XOR + COMPLEMENT UNDER THE MASK, new, uber imported
2151 Maximum Good People Based on Statements Python O(2^n * n^2) O(1) Hard bit manipulation, ENUMERATE EVERY GOOD/BAD ASSIGNMENT (n <= 15 -> 2^15 masks), new imported
2212 Maximum Points in an Archery Competition Python O(2^12 * 12) O(1) Medium bit manipulation, ONLY 12 SECTIONS -> ENUMERATE ALL 2^12 SUBSETS BOB COULD WIN, new imported
2220 Minimum Bit Flips to Convert Number Python O(log n) O(1) Easy bit manipulation, XOR + POPCOUNT (Hamming distance), new imported
2275 Largest Combination With Bitwise AND Greater Than Zero Python O(n * 24) O(24) Medium bit manipulation, THE AND IS NON-ZERO IFF SOME BIT SURVIVES — COUNT PER BIT COLUMN, new imported
2317 Maximum XOR After Operations Python O(n) O(1) Medium bit manipulation, BIT MANIPULATION (the operation can only CLEAR bits -> answer is OR), new imported
2397 Maximum Rows Covered by Columns Python O(2^n * m) O(m) Medium bit manipulation, BITMASK BRUTE FORCE (n <= 12 -> only 4096 column subsets), new imported
2411 Smallest Subarrays With Maximum Bitwise OR Python O(n * 30) O(30) Medium bit manipulation, PER BIT, REMEMBER THE NEAREST INDEX TO THE RIGHT THAT SETS IT, new imported
2419 Longest Subarray With Maximum Bitwise AND Python O(n) O(1) Medium bit manipulation, ANDing MORE ELEMENTS ONLY CLEARS BITS — SO THE BEST AND IS max(nums), new imported
2425 Bitwise XOR of All Pairings Python O(n + m) O(1) Medium bit manipulation, EACH ELEMENT APPEARS ONCE PER ELEMENT OF THE OTHER ARRAY — PARITY DECIDES, new imported
2429 Minimize XOR Python O(30) O(1) Medium bit manipulation, SPEND THE BIT BUDGET ON num1’s HIGHEST SET BITS, THEN THE LOWEST GAPS, new imported
2505 Bitwise OR of All Subsequence Sums Python O(n * 32 + 64) O(64) Medium bit manipulation, 🔒, BIT COUNTING + CARRY PROPAGATION, new imported
2527 Find Xor-Beauty of Array Python O(n) O(1) Medium bit manipulation, BIT MANIPULATION / CANCELLATION -> ANSWER IS JUST XOR OF ALL ELEMENTS, new imported
2595 Number of Even and Odd Bits Python O(log n) O(1) Easy bit manipulation, BIT SCAN (walk bits low -> high, flip the bucket each step), new imported
2859 Sum of Values at Indices With K Set Bits Python O(n * log n) O(1) Easy bit manipulation, POPCOUNT VIA n & (n - 1) BIT TRICK, new imported
2935 Maximum Strong Pair XOR II Python O(n * log n + n * 20) O(n * 20) Hard bit manipulation, SORT + SLIDING WINDOW OVER A COUNTING BINARY TRIE, new imported
2980 Check if Bitwise OR Has Trailing Zeros Python O(n) O(1) Easy bit manipulation, BIT MANIPULATION (COUNT EVEN NUMBERS), new imported
3125 Maximum Number That Makes Result of Bitwise AND Zero Python O(1) O(1) Medium bit manipulation, 🔒, THE ANSWER IS ALWAYS 2^h - 1, WHERE h IS n’S HIGHEST SET BIT, new imported
3133 Minimum Array End Python O(log n + log x) O(1) Medium bit manipulation, EVERY ELEMENT MUST BE A SUPERSET OF x’S BITS — SO COUNT IN THE FREE BITS, new, neetcode250 imported
3226 Number of Bit Changes to Make Two Integers Equal Python O(1) O(1) Easy bit manipulation, ONLY 1 -> 0 IS ALLOWED, SO k’S BITS MUST BE A SUBSET OF n’S, new imported
3289 The Two Sneaky Numbers of Digitville Python O(n) O(n) Easy bit manipulation, A SEEN-SET — THE SECOND SIGHTING IDENTIFIES A CULPRIT, new imported
3304 Find the K-th Character in String Game I Python O(1) O(1) Easy bit manipulation, EACH DOUBLING SHIFTS THE COPY BY ONE — SO COUNT THE SET BITS OF k-1, new imported
3307 Find the K-th Character in String Game II Python O(len(operations)) O(1) Hard bit manipulation, WALK THE OPERATIONS BACKWARDS, FOLDING k INTO THE FIRST HALF, new imported
3314 Construct the Minimum Bitwise Array I Python O(n log max) O(n) Easy bit manipulation, x OR (x+1) ONLY EVER SETS A RUN OF LOW BITS — SO CLEAR ONE OF THEM, new imported
3315 Construct the Minimum Bitwise Array II Python O(n log max) O(n) Medium bit manipulation, SAME BIT RULE AS LC 3314 — THE VALUES JUST GET BIGGER, new imported
3370 Smallest Number With All Set Bits Python O(1) O(1) Easy bit manipulation, THE ALL-ONES NUMBERS ARE 2^b - 1 — TAKE THE FIRST ONE THAT REACHES n, new imported
3566 Partition Array into Two Equal Product Subsets Python O(2^n * n) O(1) Medium bit manipulation, BITMASK ENUMERATION OVER EVERY SPLIT, new imported
3632 Subarrays with XOR at Least K Python O(n log C) O(n) Hard bit manipulation, 🔒, COUNT THE COMPLEMENT, ONE BIT OF K AT A TIME, new imported
3646 Next Special Palindrome Number Python O(C log C) where C ~ 1e5 candidates O© Hard bit manipulation, ENUMERATE EVERY SPECIAL NUMBER ONCE, THEN BINARY SEARCH, new imported

Breadth-First Search

# Title Solution Time Space Difficulty Note Status
0773 Sliding Puzzle Python, Java O(1) O(1) Hard bfs, BFS over board states encoded as strings, LC 752, good trick, new, google, amazon, fb, uber imported
0854 K-Similar Strings Python, Java O(n^2 * n!) O(n!) Hard bfs, BFS over swap states with pruning, good trick, new, google, amazon imported
0882 Reachable Nodes In Subdivided Graph Python, Java O(eloge) O(n + e) Hard bfs, Dijkstra on the original graph then count the subdivided nodes, good trick, new, heap imported
0913 Cat and Mouse Python, Java O(n^3) O(n^2) Hard bfs, minimax BFS over (mouse, cat, turn) states, game theory, complex, new, math, dp, graph, google imported
1034 Coloring A Border Python O(m * n) O(m * n) Medium bfs, BFS (collect whole component first, then repaint only its border), new, amazon, fb imported
1036 Escape a Large Maze Python O(m^2), m = len(blocked) O(m^2) Hard bfs, BOUNDED BFS (the key trick), new, google, uber imported
1129 Shortest Path with Alternating Colors Python O(n + m) O(n + m) Medium bfs, BFS on a “doubled” state graph, new, google, amazon imported
1161 Maximum Level Sum of a Binary Tree Python O(n) O(n) Medium bfs, BFS (level order traversal), new, google, amazon, fb, microsoft imported
1203 Sort Items by Groups Respecting Dependencies Python O(n + m + E), E = total number of beforeItems edges O(n + m + E) Hard bfs, TWO-LEVEL TOPOLOGICAL SORT (BFS / Kahn), new, google, apple imported
1210 Minimum Moves to Reach Target with Rotations Python O(n^2) O(n^2) Hard bfs, BFS on state = (row, col, orientation), new imported
1215 Stepping Numbers Python O(2^d), d = number of digits of high O(2^d) Medium bfs, 🔒, BFS (build stepping numbers digit by digit), new imported
1245 Tree Diameter Python O(n) O(n) Medium bfs, DOUBLE BFS (two-sweep), new, google, amazon, fb imported
1263 Minimum Moves to Move a Box to Their Target Location Python O((m * n)^2) O((m * n)^2) Hard bfs, 0-1 BFS on state (box position, player position), new, google, fb imported
1284 Minimum Number of Flips to Convert Binary Matrix to Zero Matrix Python O(2^(m*n) * m * n) O(2^(m*n)) Hard bfs, BFS over BITMASK states, new, google imported
1291 Sequential Digits Python O(1), at most 36 candidates O(1) Medium bfs, ENUMERATE all sequential numbers (there are only 36 of them), new, amazon, apple imported
1293 Shortest Path in a Grid with Obstacles Elimination Python O(m * n * k) O(m * n * k) Hard bfs, BFS on the 3D STATE (row, col, remaining_k), new, google, amazon, fb, apple imported
1298 Maximum Candies You Can Get from Boxes Python O(n + total keys + total contained) O(n) Hard bfs, BFS (a box becomes openable when it is BOTH owned and unlocked), new imported
1302 Deepest Leaves Sum Python O(n) O(w) w = max level width Medium bfs, BFS LEVEL ORDER (keep only the last level’s sum), new, google, amazon, apple, microsoft imported
1306 Jump Game III Python O(n) O(n) Medium bfs, BFS + visited set, new, google, amazon, fb, apple imported
1311 Get Watched Videos by Your Friends Python O(n + m + v log v) O(n + v) Medium bfs, BFS level by level + counting + custom sort, new, amazon imported
1345 Jump Game IV Python O(n) O(n) Hard bfs, BFS (level by level = shortest number of steps), new, google, amazon imported
1368 Minimum Cost to Make at Least One Valid Path in a Grid Python O(m * n) O(m * n) Hard bfs, 0-1 BFS (deque), new, google, uber imported
1602 Find Nearest Right Node in Binary Tree Python O(n) O(width of the tree) Medium bfs, 🔒, LEVEL-ORDER BFS (the “next node right” is the next queue entry), new, google imported
1625 Lexicographically Smallest String After Applying Operations Python O(n^2 * 100) worst case O(n) Medium bfs, ENUMERATE THE REACHABLE SET (rotations x independent digit shifts), new imported
1654 Minimum Jumps to Reach Home Python O(LIMIT) O(LIMIT) Medium bfs, BFS over state (position, came-here-by-backward-jump?), new, amazon, apple imported
1660 Correct a Binary Tree Python O(n) O(n) Medium bfs, 🔒, DFS VISITING RIGHT-TO-LEFT (the bad edge points to an ALREADY seen node), new, google imported
1728 Cat and Mouse II Python O((mn)^2 * (m + n)) O((mn)^2) Hard bfs, GAME THEORY, RETROGRADE ANALYSIS (BFS backwards from terminal states), new, google imported
1926 Nearest Exit from Entrance in Maze Python O(m * n) O(m * n) Medium bfs, BFS LEVEL BY LEVEL (unweighted grid -> first border cell reached wins), new, amazon, fb, uber imported
1928 Minimum Cost to Reach Destination in Time Python O(maxTime * m) O(maxTime * n) Hard bfs, DP OVER (TIME, CITY) - a “layered graph” shortest path relaxed by time, new, google, fb imported
2039 The Time When the Network Becomes Idle Python O(V + E) O(V + E) Medium bfs, BFS SHORTEST PATH FROM NODE 0 + PER-NODE ARITHMETIC, new imported
2045 Second Minimum Time to Reach Destination Python O(V + E) O(V + E) Hard bfs, BFS TRACKING THE TWO SMALLEST EDGE COUNTS PER NODE, THEN SIMULATE, new imported
2050 Parallel Courses III Python O(n + m) O(n + m), m = len(relations) Hard bfs, TOPOLOGICAL SORT + DP (longest path in a DAG, node weight = time), new, google imported
2059 Minimum Operations to Convert Number Python O(1000 * n) O(1000), n = len(nums) Medium bfs, BFS OVER THE 1001 REACHABLE STATES (shortest number of operations), new, google imported
2146 K Highest Ranked Items Within a Price Range Python O(m * n log(m * n)) O(m * n) Medium bfs, BFS FROM THE START, THEN SORT THE COLLECTED ITEMS BY THE RANK TUPLE, new imported
2258 Escape the Spreading Fire Python O(m * n * log(m * n)) O(m * n) Hard bfs, BFS THE FIRE ONCE, THEN BINARY SEARCH THE WAITING TIME, new imported
2368 Reachable Nodes With Restrictions Python O(n) O(n) Medium bfs, BFS FROM NODE 0, TREATING RESTRICTED NODES AS WALLS, new imported
2471 Minimum Number of Operations to Sort a Binary Tree by Level Python O(n log n) O(n) Medium bfs, PER LEVEL, THE MINIMUM SWAPS TO SORT = size - (number of cycles), new imported
2492 Minimum Score of a Path Between Two Cities Python O(V + E) O(V + E) Medium bfs, ROADS MAY BE REUSED — SO EVERY EDGE IN 1’s COMPONENT IS REACHABLE, new imported
2493 Divide Nodes Into the Maximum Number of Groups Python O(V * (V + E)) O(V + E) Hard bfs, THE GROUPING IS A BFS LAYERING — TRY EVERY START, PER COMPONENT, new imported
2503 Maximum Number of Points From Grid Queries Python O(mnlog(mn) + klog k) O(m*n) Hard bfs, OFFLINE QUERIES (SORT) + BEST-FIRST BFS WITH A MIN HEAP, new imported
2577 Minimum Time to Visit a Cell In a Grid Python O(m * n * log(m * n)) O(m * n) Hard bfs, DIJKSTRA (BFS + MIN HEAP) + PARITY WAITING TRICK, new imported
2583 Kth Largest Sum in a Binary Tree Python O(n * log n) O(n) Medium bfs, BFS (level order traversal) + SORT, new imported
2603 Collect Coins in a Tree Python O(n) O(n) Hard bfs, TOPOLOGICAL (LEAF) PRUNING x 2 ROUNDS, new imported
2612 Minimum Reverse Operations Python O((n + len(banned)) * alpha(n)) O(n) Hard bfs, BFS over an INTERVAL of same-parity targets + UNION-FIND “next unvisited”, new imported
2814 Minimum Time Takes to Reach Destination Without Drowning Python O(n * m) O(n * m) Hard bfs, 🔒, TWO BFS - FLOOD SPREAD FIRST, THEN THE WALKER, new imported
3157 Find the Level of Tree with Minimum Sum Python O(n) O(width) Medium bfs, 🔒, LEVEL-ORDER BFS, TRACKING THE BEST SUM AND ITS LEVEL, new imported
3286 Find a Safe Walk Through a Grid Python O(m * n) O(m * n) Medium bfs, 0-1 BFS — MINIMISE THE DAMAGE TAKEN, THEN COMPARE WITH health, new imported
3373 Maximize the Number of Target Nodes After Connecting Trees II Python O(n + m) O(n + m) Hard bfs, “EVEN DISTANCE” IS A 2-COLOURING — SO COUNTING COLLAPSES TO PARITIES, new imported
3528 Unit Conversion I Python O(n) O(n) Medium bfs, THE CONVERSIONS FORM A TREE ROOTED AT 0 – ONE DFS MULTIPLIES ALONG IT, new imported
3535 Unit Conversion II Python O(n + q * log MOD) O(n) Medium bfs, 🔒, ROOT THE CONVERSION TREE AT UNIT 0 AND STORE ONE RATIO PER NODE, new imported
3552 Grid Teleportation Traversal Python O(m*n) O(m*n) Medium bfs, 0-1 BFS — TELEPORTS ARE ZERO-COST EDGES, new imported
3568 Minimum Moves to Clean the Classroom Python O(m * n * 2^L * energy) O(m * n * 2^L) Medium bfs, BFS OVER (ROW, COL, COLLECTED-MASK) KEEPING THE BEST ENERGY, new imported
3619 Count Islands With Total Value Divisible by K Python O(m * n) O(m * n) Medium bfs, BFS FLOOD FILL, SUMMING EACH COMPONENT AS IT IS CONSUMED, new imported
3629 Minimum Jumps to Reach End via Prime Teleportation Python O(max(nums) log log max(nums) + n log max(nums)) O(max(nums) + n log max(nums)) Medium bfs, BFS + SMALLEST-PRIME-FACTOR SIEVE, EACH PRIME BUCKET USED ONCE, new imported

Constructive Algorithms

# Title Solution Time Space Difficulty Note Status
2202 Maximize the Topmost Element After K Moves Python O(n) O(1) Medium constructive, CASE ANALYSIS ON WHAT k MOVES CAN REACH, new imported
2335 Minimum Amount of Time to Fill Cups Python O(1) O(1) Easy constructive, TWO LOWER BOUNDS, AND THE LARGER ONE IS ALWAYS ACHIEVABLE, new imported
2350 Shortest Impossible Sequence of Rolls Python O(n) O(k) Hard constructive, GREEDY SEGMENT SPLIT (count complete “all k faces” blocks), new imported
2358 Maximum Number of Groups Entering a Competition Python O(1) O(1) Medium constructive, MATH / GREEDY (only the group SIZES matter), new imported
2546 Apply Bitwise Operations to Make Strings Equal Python O(n) O(1) Medium constructive, CONSTRUCTIVE / INVARIANT (“does the string contain any 1 at all?”), new imported
2610 Convert an Array Into a 2D Array With Conditions Python O(n) O(n) Medium constructive, COUNTING (bucket the c-th copy of a value into row c), new imported
2647 Color the Triangle Red Python O(n^2) (that is the size of the output itself) O(1) extra Hard constructive, 🔒, CONSTRUCTIVE / GREEDY PATTERN (walk the rows BOTTOM-UP in blocks of 4), new imported
2654 Minimum Number of Operations to Make All Array Elements Equal to 1 Python O(n^2 * log(max(nums))) O(1) Medium constructive, GCD + SHORTEST SUBARRAY WHOSE GCD IS 1, new imported
2728 Count Houses in a Circular Street Python O(k) O(1) Easy constructive, 🔒, INTERACTIVE - NORMALIZE THE STREET, THEN CLOSE-AND-COUNT ONE LAP, new imported
2732 Find a Good Subset of the Matrix Python O(m * n + 4^n) O(2^n) Hard constructive, BITMASK ROWS + PROOF THAT ONLY k = 1 OR k = 2 CAN EVER WIN, new imported
2745 Construct the Longest New String Python O(1) O(1) Medium constructive, GREEDY / CASE ANALYSIS ON THE “AA” vs “BB” ALTERNATION, new imported
2753 Count Houses in a Circular Street II Python O(k) O(1) Hard constructive, 🔒, INTERACTIVE / BRAIN TEASER – use one open door as an anchor, new imported
2811 Check if it is Possible to Split Array Python O(n) O(1) Medium constructive, GREEDY / OBSERVATION ON THE LAST SPLIT, new imported
2829 Determine the Minimum Sum of a k-avoiding Array Python O(n + k) O(n + k) Medium constructive, GREEDY (take the smallest still-legal integer each time), new imported
2834 Find the Minimum Possible Sum of a Beautiful Array Python O(1) O(1) Medium constructive, GREEDY + ARITHMETIC SERIES (closed form, no loop), new imported
2849 Determine if a Cell Is Reachable at a Given Time Python O(1) O(1) Medium constructive, MATH (Chebyshev distance + a single degenerate case), new imported
2856 Minimum Array Length After Pair Removals Python O(n) O(1) Medium constructive, MAJORITY-ELEMENT COUNTING (greedy pairing argument), new imported
3139 Minimum Cost to Equalize Array Python O(n + max(nums)) O(1) Hard constructive, FIX THE TARGET, THEN THE ONLY QUESTION IS HOW MANY INCREMENTS PAIR UP, new imported
3260 Find the Largest Palindrome Divisible by K Python O(n * 10 * k) O(n * k) Hard constructive, ONLY THE FIRST HALF IS FREE, AND EACH DIGIT HAS A FIXED WEIGHT MOD k, new imported
3375 Minimum Operations to Make Array Values Equal to K Python O(n) O(n) Easy constructive, EACH OPERATION ERASES EXACTLY ONE DISTINCT VALUE ABOVE k, new imported
3680 Generate Schedule Python O(n^2) O(1) besides the output Medium constructive, GROUP THE MATCHES BY CIRCULAR GAP, THEN WALK EACH GAP IN ORDER, new imported

Depth-First Search

# Title Solution Time Space Difficulty Note Status
0440 K-th Smallest in Lexicographical Order Python, Java O((logn)^2) O(1) Hard dfs, count nodes in each 10-ary prefix subtree, LC 386, good trick, new, trie, google imported
0749 Contain Virus Python, Java O((m * n)^2) O(m * n) Hard dfs, simulate rounds, dfs each region, count walls, complex, new, bloomberg imported
1059 All Paths from Source Lead to Destination Python O(V + E) O(V + E) Medium dfs, 🔒, DFS + 3 color (white / gray / black) cycle detection, new, google, amazon imported
1202 Smallest String With Swaps Python O(n log n + m), n = len(s), m = len(pairs) O(n) Medium dfs, UNION FIND (connected components), new, google, fb, apple imported
1273 Delete Tree Nodes Python O(n) O(n) Medium dfs, POST ORDER DFS (iterative, so a 10^4 deep chain is safe), new imported
1315 Sum of Nodes with Even-Valued Grandparent Python O(n) O(h), h = tree height (recursion depth) Medium dfs, DFS carrying (parent value, grandparent value), new, amazon imported
1319 Number of Operations to Make Network Connected Python O((n + m) * a(n)) O(n) a = inverse Ackermann Medium dfs, UNION FIND (count components; every extra cable can join two of them), new, amazon, fb, apple, microsoft imported
1367 Linked List in Binary Tree Python O(n * m) O(n) Medium dfs, DOUBLE RECURSION (try to “start the match” at every tree node), new, amazon, microsoft imported
1377 Frog Position After T Seconds Python O(n) O(n) Hard dfs, DFS on the tree, carry the accumulated probability down, new, google, amazon imported
1391 Check if There is a Valid Path in a Grid Python O(m * n * alpha(m * n)) O(m * n) Medium dfs, UNION FIND (a street type = a fixed pair of open sides), new, google, uber imported
1485 Clone Binary Tree With Random Pointer Python O(n) O(n) Medium dfs, 🔒, DFS + OLD->NEW MAP (create the copy BEFORE recursing), new, amazon, fb imported
1722 Minimize Hamming Distance After Swap Operations Python O(n * alpha(n)) O(n) Medium dfs, UNION FIND + PER-COMPONENT MULTISET, new, google, amazon imported
1766 Tree of Coprimes Python O(n * 50) O(n) Hard dfs, DFS + PER-VALUE ANCESTOR STACKS (values are only 1…50), new, google imported
1973 Count Nodes Equal to Sum of Descendants Python O(n) O(n) Medium dfs, 🔒, POST-ORDER DFS (bottom-up subtree sums), new, fb imported
2065 Maximum Path Quality of a Graph Python O(n + m + 4^(maxTime/min_time)) O(n + m) Hard dfs, EXHAUSTIVE DFS (the time budget bounds the walk length), new, fb imported
2192 All Ancestors of a Node in a Directed Acyclic Graph Python O(n * (V + E)) O(V + E) Medium dfs, ONE DFS PER SOURCE — MARK THAT SOURCE ON EVERYTHING IT REACHES, new imported
2246 Longest Path With Different Adjacent Characters Python O(n) O(n) Hard dfs, TREE DP — AT EACH NODE, JOIN ITS TWO BEST DOWNWARD CHAINS, new imported
2265 Count Nodes Equal to Average of Subtree Python O(n) O(n) Medium dfs, ITERATIVE POST-ORDER DFS (bubble up (sum, count) per subtree), new imported
2322 Minimum Score After Removals on a Tree Python O(n^2) O(n) Hard dfs, ROOT THE TREE, THEN AN EDGE IS JUST “THE SUBTREE BELOW IT”, new imported
2385 Amount of Time for Binary Tree to Be Infected Python O(n) O(n) Medium dfs, THE INFECTION IGNORES THE PARENT/CHILD DIRECTION — MAKE IT A GRAPH, new imported
2445 Number of Nodes With Value One Python O(n + q) O(n) Medium dfs, 🔒, LAZY FLIP TAG + TOP-DOWN PROPAGATION (heap-indexed tree, parent = i // 2), new imported
2458 Height of Binary Tree After Subtree Removal Queries Python O(n + m) O(n) Hard dfs, PRECOMPUTE, FOR EVERY NODE, THE TREE HEIGHT WITHOUT ITS SUBTREE, new imported
2467 Most Profitable Path in a Tree Python O(n) O(n) Medium dfs, BOB’S ROUTE IS FIXED — TIME-STAMP IT, THEN LET ALICE PICK A LEAF, new imported
2477 Minimum Fuel Cost to Report to the Capital Python O(n) O(n) Medium dfs, GREEDY ON SUBTREE SIZES (every edge is crossed ceil(sz / seats) times), new imported
2581 Count Number of Possible Root Nodes Python O(n + m) O(n + m) (m = len(guesses)) Hard dfs, REROOTING TREE DP (2 passes, iterative), new imported
2773 Height of Special Binary Tree Python O(n) O(n) Medium dfs, 🔒, DFS THAT FILTERS OUT THE FAKE LEAF-TO-LEAF LINKS, new imported
2791 Count Paths That Can Form a Palindrome in a Tree Python O(26 * n) O(n) Hard dfs, ROOT-TO-NODE XOR BITMASK + PAIR COUNTING, new imported
3004 Maximum Subtree of the Same Color Python O(n) O(n) Medium dfs, 🔒, POST-ORDER DFS — A SUBTREE IS UNIFORM IFF ALL ITS CHILDREN ARE, new imported
3067 Count Pairs of Connectable Servers in a Weighted Tree Network Python O(n^2) O(n) Medium dfs, ROOT AT EACH SERVER, COUNT PER BRANCH, MULTIPLY ACROSS BRANCHES, new imported
3203 Find Minimum Diameter After Merging Two Trees Python O(n + m) O(n + m) Hard dfs, JOIN THE TWO CENTRES — THE ANSWER IS A MAX OF THREE TERMS, new imported
3249 Count the Number of Good Nodes Python O(n) O(n) Medium dfs, POST-ORDER SUBTREE SIZES, THEN COMPARE EACH NODE’S CHILDREN, new imported
3327 Check if DFS Strings Are Palindromes Python O(n) O(n) Hard dfs, ONE GLOBAL DFS STRING — EVERY SUBTREE IS A CONTIGUOUS SLICE OF IT, new imported
3331 Find Subtree Sizes After Changes Python O(n) O(n) Medium dfs, ONE DFS CARRYING A STACK OF ANCESTORS PER LETTER, new imported
3367 Maximize Sum of Weights after Edge Removals Python O(n log n) O(n) Hard dfs, TREE DP ON “IS THE EDGE TO MY PARENT KEPT ?”, new imported
3590 Kth Smallest Path XOR Sum Python O((n + q) * log(max_val)) O(n * log(max_val)) Hard dfs, MERGEABLE BINARY TRIE OVER THE XOR VALUES, MERGED BOTTOM-UP, new imported
3593 Minimum Increments to Equalize Leaf Paths Python O(n) O(n) Medium dfs, BOTTOM-UP MAX, CHARGING ONE OPERATION PER SHORT CHILD, new imported
3607 Power Grid Maintenance Python O((c + n + q) * log©) O© Medium dfs, UNION-FIND + PER-GRID MIN-HEAP WITH LAZY DELETION, new imported

Design

# Title Solution Time Space Difficulty Note Status
1348 Tweet Counts Per Frequency Python O(log n) per record, O(c * log n) per query (c = number of chunks) O(n) Medium design, SORTED LIST PER TWEET + BINARY SEARCH per chunk, new, amazon imported
1352 Product of the Last K Numbers Python O(1) per add / getProduct O(n) Medium design, PREFIX PRODUCTS, reset on every 0, new, google, amazon, apple, uber imported
1357 Apply Discount Every n Orders Python O(m) per getBill (m = #distinct products in that bill), O(k) init O(k), k = len(products) Medium design, HASH TABLE (product id -> price) + CUSTOMER COUNTER MOD n, new, fb imported
1476 Subrectangle Queries Python O(rows * cols) per update, O(1) per getValue O(rows * cols) Medium design, BRUTE FORCE UPDATE (just overwrite the cells), new imported
1483 Kth Ancestor of a Tree Node Python O(n log n) build, O(log n) per query O(n log n) Hard design, BINARY LIFTING (jump 2^j steps at a time), new, google, amazon imported
1570 Dot Product of Two Sparse Vectors Python O(n) to build, O(min(k1, k2)) per dot product O(k), k = number of non-zero entries Medium design, 🔒, HASH TABLE (keep only the non-zero entries), new, google, amazon, fb, apple, microsoft imported
1586 Binary Search Tree Iterator II Python O(n) to build, O(1) per call O(n) Medium design, 🔒, FLATTEN THE BST + CURSOR (in-order gives a sorted array), new, fb imported
1600 Throne Inheritance Python O(1) for birth / death, O(n) for getInheritanceOrder O(n) Medium design, N-ARY TREE + PRE-ORDER DFS (the inheritance order IS a pre-order walk), new, google, amazon imported
1622 Fancy Sequence Python O(1) for append (amortised, O(log MOD) for the inverse), O(1) others O(n) Hard design, LAZY AFFINE TRANSFORM + MODULAR INVERSE, new, google, apple imported
1804 Implement Trie II (Prefix Tree) Python O(L) per operation, L = len(word) O(total inserted chars) Medium design, 🔒, TRIE WITH TWO COUNTERS PER NODE (word count + prefix count), new, apple imported
1825 Finding MK Average Python O(log M) per addElement / calculateMKAverage, M = 10^5 O(M + m) Hard design, SLIDING WINDOW (deque) + FENWICK TREE INDEXED BY VALUE, new, google imported
1865 Finding Pairs With a Certain Sum Python O(1) per add, O(len(nums1)) per count O(len(nums2)) Medium design, DESIGN - HASH COUNTER ON THE BIG ARRAY, LOOP OVER THE SMALL ONE, new imported
1912 Design Movie Rental System Python O(m log m) init, O(log m) per rent/drop, O(1) per search/report O(m), m = len(entries) Hard design, ORDERED SETS (one sorted list per movie + one global sorted list), new imported
1993 Operations on Tree Python O(1) lock / unlock, O(n) upgrade O(n) Medium design, DESIGN - parent array (walk up) + children lists (walk down), new, google imported
2043 Simple Bank System Python O(1) per operation O(n) Medium design, PLAIN ARRAY + TWO VALIDATION HELPERS, new imported
2069 Walking Robot Simulation II Python O(width + height) to build, O(1) per call O(width + height) Medium design, THE ROBOT IS PERMANENTLY ON THE PERIMETER — WALK A CYCLIC RING, new imported
2080 Range Frequency Queries Python O(n) build, O(log n) per query O(n) Medium design, VALUE -> SORTED LIST OF ITS INDICES, THEN BINARY SEARCH THE RANGE, new imported
2102 Sequentially Ordinal Rank Tracker Python O(log n) per call O(n) Hard design, TWO HEAPS STRADDLING THE ANSWER POSITION, new, amazon imported
2166 Design Bitset Python O(1) per op except toString(), which is O(size) O(size) Medium design, STORE THE BITS AND A LAZY “INVERTED” FLAG SO flip() IS O(1), new imported
2227 Encrypt and Decrypt Strings Python init O(sum(len(dictionary[i]))), encrypt O(len(word1)), decrypt O(1) O(len(keys) + total dictionary length) Hard design, REVERSE THE QUESTION - PRE-ENCRYPT THE DICTIONARY, new imported
2241 Design an ATM Machine Python O(5) per call O(1) Medium design, FIXED LARGEST-FIRST GREEDY, COMMITTED ONLY IF IT FULLY SUCCEEDS, new imported
2254 Design Video Sharing Platform Python O(log n) for upload, O(1) for the rest (watch is O(slice length)) O(total content) Hard design, 🔒, DICT OF LIVE VIDEOS + A MIN-HEAP OF RECYCLED IDs, new imported
2276 Count Integers in Intervals Python O(log n) amortised per add, O(1) per count O(n) Hard design, KEEP THE INTERVALS DISJOINT AND MERGE ON INSERT, new imported
2286 Booking Concert Tickets in Groups Python O(log n) per gather, amortised O(log n) per scatter O(n) Hard design, SEGMENT TREE HOLDING (MAX FREE SEATS, TOTAL FREE SEATS) PER ROW, new imported
2296 Design a Text Editor Python O(k) per call O(total text) Hard design, TWO STACKS STRADDLING THE CURSOR, new imported
2336 Smallest Number in Infinite Set Python O(log n) per call O(n) Medium design, A FRONTIER COUNTER FOR THE UNTOUCHED TAIL + A MIN-HEAP OF RETURNS, new imported
2349 Design a Number Container System Python O(log n) amortized per change / find O(n) Medium design, HASH MAP + MIN HEAP WITH LAZY DELETION (avoid an ordered set), new imported
2353 Design a Food Rating System Python O(n log n) init, O(log n) amortized per call O(n) Medium design, HASH MAP + MIN HEAP WITH LAZY DELETION (avoid an ordered set), new imported
2408 Design SQL Python O(1) per operation O(total rows stored) Medium design, 🔒, PER TABLE, A DICT rowId -> ROW PLUS A NEVER-DECREASING ID COUNTER, new imported
2424 Longest Uploaded Prefix Python O(1) amortised per call O(n) Medium design, A SET OF UPLOADS PLUS A POINTER THAT ONLY EVER MOVES FORWARD, new imported
2502 Design Memory Allocator Python O(n) per call O(n) Medium design, DIRECT SIMULATION ON A UNIT ARRAY, new imported
2526 Find Consecutive Integers from a Data Stream Python O(1) per consec call O(1) Medium design, RUNNING STREAK COUNTER (no queue needed), new imported
2590 Design a Todo List Python O(1) addTask, O(n log n) per read, O(n) completeTask O(n) Medium design, 🔒, HASH MAP (user -> task list) + SORT ON READ, new imported
2671 Frequency Tracker Python O(1) per operation O(n) with n = #distinct numbers added Medium design, TWO COUNTERS – “count of each number” + “count of each count”, new imported
3242 Design Neighbor Sum Service Python O(n^2) to build, O(1) per query O(n^2) Easy design, INDEX THE VALUES ONCE, THEN EACH QUERY IS FOUR BOUNDED LOOKUPS, new imported
3408 Design Task Manager Python O(log n) amortised per operation O(number of pushes) Medium design, MAX-HEAP WITH LAZY DELETION, DICT AS THE SOURCE OF TRUTH, new imported
3508 Implement Router Python O(1) add / forward amortised, O(log n) getCount O(n) Medium design, FIFO QUEUE + PER-DESTINATION TIMESTAMP LIST WITH A CONSUMED POINTER, new imported

Dynamic Programming

# Title Solution Time Space Difficulty Note Status
0087 Scramble String Python, Java O(n^4) O(n^3) Hard dp, 3D interval dp / memoized recursion on (i, j, len), new, google, amazon, apple imported
0174 Dungeon Game Python, Java O(m * n) O(m * n) Hard dp, 2D dp filled from the bottom-right, track the min health needed, good trick, new, google, amazon, microsoft, uber imported
0188 Best Time to Buy and Sell Stock IV Python, Java O(n * k) O(k) Hard dp, LC 122, LC 123, k-transaction stock dp, state machine, new, google, amazon, fb, apple, uber imported
0446 Arithmetic Slices II - Subsequence Python, Java O(n^2) O(n^2) Hard dp, dp with a hashmap of (index, diff), LC 413, good trick, new, google, fb, uber imported
0465 Optimal Account Balancing Python, Java O(m!) O(m) Hard dp, 🔒, net balances then backtracking over settlements, bitmask dp, new, google, amazon, uber imported
0466 Count The Repetitions Python, Java O(l1 * l2 + n1) O(l2) Hard dp, find the repeating pattern of s2 matches inside s1, good trick, new, amazon imported
0514 Freedom Trail Python, Java O(m * n^2) O(n) Hard dp, dp over (ring position, key index), precompute char positions, new, google imported
0546 Remove Boxes Python, Java O(n^4) O(n^3) Hard dp, 3D interval dp on (l, r, k attached same-colour boxes), new, amazon, apple, uber imported
0568 Maximum Vacation Days Python, Java O(k * n^2) O(n) Hard dp, 🔒, dp over (week, city) with a flight matrix, new, google, fb, microsoft imported
0600 Non-negative Integers without Consecutive Ones Python, Java O(1) O(1) Hard dp, digit dp with Fibonacci counts, bit manipulation, good trick, new imported
0629 K Inverse Pairs Array Python, Java O(n * k) O(k) Hard dp, dp on (n, k) with a sliding-window prefix sum, mod 1e9+7, new imported
0656 Coin Path Python, Java O(n * maxJump) O(n) Hard dp, 🔒, dp from the back, lexicographically smallest path, new, google imported
0664 Strange Printer Python, Java O(n^3) O(n^2) Hard dp, interval dp, print the leftmost char across the whole range, new, google imported
0689 Maximum Sum of 3 Non-Overlapping Subarrays Python, Java O(n) O(n) Hard dp, prefix sums + best-left / best-right arrays, LC 643, new, google, fb imported
0691 Stickers to Spell Word Python, Java O(2^l * n * l) O(2^l) Hard dp, bitmask dp over target letters, BFS alternative, new, fb imported
0730 Count Different Palindromic Subsequences Python, Java O(n^2) O(n^2) Hard dp, interval dp counting distinct palindromic subsequences, mod, new, google, amazon, fb, apple, linkedin imported
0741 Cherry Pickup Python, Java O(n^3) O(n^2) Hard dp, two walkers moving simultaneously, 3D dp, LC 1463, new, google, amazon, fb, uber imported
0805 Split Array With Same Average Python, Java O(2^(n/2)) O(2^(n/2)) Hard dp, meet in the middle over subset sums, good trick, new, google, amazon, apple, microsoft, uber imported
0818 Race Car Python, Java O(target * log(target)) O(target) Hard dp, BFS over (position, speed) or dp, good trick, new, google, amazon, microsoft imported
0847 Shortest Path Visiting All Nodes Python, Java O(n^2 * 2^n) O(n * 2^n) Hard dp, bitmask BFS/dp over visited sets, TSP-style, good trick, new, google, amazon, fb imported
0879 Profitable Schemes Python, Java O(m * n * minProfit) O(n * minProfit) Hard dp, 3D knapsack dp on (members, profit), mod, new, google, linkedin imported
0903 Valid Permutations for DI Sequence Python, Java O(n^2) O(n) Hard dp, dp on (index, number of smaller values used), prefix sums, new imported
0920 Number of Music Playlists Python, Java O(goal * n) O(goal * n) Hard dp, combinatorial dp on (songs used, distinct songs), mod, new, google, amazon, fb imported
0940 Distinct Subsequences II Python, Java O(26 * n) O(1) Hard dp, dp with last-occurrence subtraction per letter, mod, new, google imported
0943 Find the Shortest Superstring Python, Java O(n^2 * 2^n + n^2 * l) O(n * 2^n) Hard dp, bitmask dp (TSP) over pairwise overlap, reconstruct the path, new, google, amazon imported
0956 Tallest Billboard Python, Java O(n * s) O(s) Hard dp, dp over the height difference between the two supports, new imported
0960 Delete Columns to Make Sorted III Python, Java O(m^2 * n) O(m) Hard dp, LIS over columns, LC 300, LC 944, LC 955, new, google imported
0964 Least Operators to Express Number Python, Java O((logt)^2) O((logt)^2) Hard dp, memoized recursion over base-x digits, complex, new imported
0975 Odd Even Jump Python, Java O(nlogn) O(n) Hard dp, monotonic stack / TreeMap for the next greater-or-equal, dp from the back, new, google imported
1035 Uncrossed Lines Python O(m * n) O(m * n) Medium dp, 2D DP (this is exactly “Longest Common Subsequence”), new, amazon imported
1039 Minimum Score Triangulation of Polygon Python O(n^3) O(n^2) Medium dp, INTERVAL DP, new, uber imported
1043 Partition Array for Maximum Sum Python O(n * k) O(n) Medium dp, 1D DP, new, amazon, fb imported
1092 Shortest Common Supersequence Python O(m * n) O(m * n) Hard dp, LCS (2D DP) + BACKTRACK the DP table, new, google, amazon, microsoft imported
1105 Filling Bookcase Shelves Python O(n^2) O(n) Medium dp, 1D DP (partition the ordered list into consecutive shelves), new, google, amazon, bloomberg imported
1125 Smallest Sufficient Team Python O(2^m * n) O(2^m) m = len(req_skills), n = len(people) Hard dp, BITMASK DP over skill sets (m <= 16 -> only 2^16 states), new, google imported
1139 Largest 1-Bordered Square Python O(m * n * min(m, n)) O(m * n) Medium dp, DP (suffix counts) + ENUMERATION, new, amazon imported
1155 Number of Dice Rolls With Target Sum Python O(n * k * target) O(target) Medium dp, 2D DP -> rolling 1D array, new, google, amazon, microsoft imported
1182 Shortest Distance to Target Color Python O(n + q) O(n) Medium dp, 🔒, PREFIX / SUFFIX DP (nearest occurrence of each color on each side), new, google, uber imported
1186 Maximum Subarray Sum with One Deletion Python O(n) O(1) Medium dp, KADANE with 2 STATES (DP), new imported
1187 Make Array Strictly Increasing Python O(n * m log m) O(m) Hard dp, DP over “last value kept” + BINARY SEARCH, new, google imported
1191 K-Concatenation Maximum Sum Python O(n) O(1) Medium dp, PREFIX SUM + CASE DISCUSSION, new, google, amazon imported
1216 Valid Palindrome III Python O(n^2) O(n^2) Hard dp, 🔒, 2D DP (Longest Palindromic Subsequence), new, amazon, fb imported
1220 Count Vowels Permutation Python O(n) O(1) Hard dp, 1D DP (count by last character), new, amazon imported
1223 Dice Roll Simulation Python O(n * 6 * M), M = max(rollMax) O(6 * M) Hard dp, 2D DP (last face + current run length), new, google, bloomberg imported
1230 Toss Strange Coins Python O(n * target) O(target) Medium dp, 1D DP (rolled from the 2D “first i coins, j heads” table), new, google imported
1235 Maximum Profit in Job Scheduling Python O(n log n) O(n) Hard dp, DP + BINARY SEARCH (weighted interval scheduling), new, google, amazon, microsoft, uber imported
1239 Maximum Length of a Concatenated String with Unique Characters Python O(2^n + L), n = len(arr), L = total chars O(2^n) Medium dp, BITMASK DP (build set of reachable “used letters” states), new, amazon, microsoft imported
1246 Palindrome Removal Python O(n^3) O(n^2) Hard dp, INTERVAL DP, new, microsoft imported
1262 Greatest Sum Divisible by Three Python O(n) O(1) Medium dp, DP ON REMAINDER, new, amazon, fb imported
1269 Number of Ways to Stay in the Same Place After Some Steps Python O(steps * min(arrLen, steps)) O(min(arrLen, steps)) Hard dp, 1D DP (rolling array), new, google, fb, apple imported
1278 Palindrome Partitioning III Python O(n^2 * k) O(n^2) Hard dp, 2 STAGE DP, new imported
1289 Minimum Falling Path Sum II Python O(n^3) O(n) Hard dp, 1D DP (rolling array), new, google imported
1301 Number of Paths with Max Score Python O(n^2) O(n^2) Hard dp, 2D DP (max score + path count, filled bottom-right -> top-left), new imported
1320 Minimum Distance to Type a Word Using Two Fingers Python O(26 * n) O(26) Hard dp, DP over “where the OTHER finger rests” (the typing finger is implicit), new, google imported
1340 Jump Game V Python O(n log n + n * d) O(n) Hard dp, SORT BY VALUE + DP, new imported
1387 Sort Integers by The Power Value Python O(n log n * M), n = hi - lo + 1, M = max chain length O(n + M) Medium dp, memoized Collatz “power” (top down DP) + sort by (power, value), new, google imported
1388 Pizza With 3n Slices Python O(n^2) O(n^2) Hard dp, CIRCULAR HOUSE ROBBER, but taking EXACTLY n slices, new, google, uber imported
1395 Count Number of Teams Python O(n^2) O(1) Medium dp, FIX THE MIDDLE SOLDIER (count smaller-left / larger-right), new, google, amazon, apple imported
1397 Find All Good Strings Python O(n * m * 26) O(n * m * 4), m = len(evil) Hard dp, DIGIT DP + KMP AUTOMATON (build the string left to right), new, google imported
1411 Number of Ways to Paint N × 3 Grid Python O(n) O(1) Hard dp, DP on ROW PATTERN TYPE (only 2 shapes matter), new, google, fb imported
1416 Restore The Array Python O(n * log10(k)) O(n) Hard dp, DP OVER SUFFIXES (cut the first number, recurse on the rest), new, amazon imported
1420 Build Array Where You Can Find The Maximum Exactly K Comparisons Python O(n * m * k) O(m * k) Hard dp, DP ON (length, prefix max, cost) + PREFIX SUM, new imported
1434 Number of Ways to Wear Different Hats to Each Other Python O(40 * 2^n * n) O(2^n) Hard dp, BITMASK DP (iterate over HATS, not people), new imported
1444 Number of Ways of Cutting a Pizza Python O(m * n * k * (m + n)) O(m * n * k) Hard dp, 2D PREFIX SUM + MEMOIZED SEARCH (state = remaining bottom-right block), new, google imported
1449 Form Largest Integer With Digits That Add up to Target Python O(target * 9) O(target) Hard dp, UNBOUNDED KNAPSACK (maximize digit count) + GREEDY RECONSTRUCTION, new, google imported
1458 Max Dot Product of Two Subsequences Python O(m * n) O(m * n) Hard dp, 2D DP (LCS-like), new imported
1463 Cherry Pickup II Python O(rows * cols^2 * 9) O(cols^2) Hard dp, DP ON BOTH ROBOTS AT ONCE (they always share the same row), new, google, apple imported
1467 Probability of a Two Boxes Having The Same Number of Distinct Balls Python O(k * n * k * maxBalls) O(k * n * k) Hard dp, COMBINATORICS + DFS OVER COLORS (count splits, not shuffles), new imported
1473 Paint House III Python O(m * n^2 * target) O(n * target) Hard dp, DP ON (house, colour, neighborhoods so far), new, apple imported
1477 Find Two Non-overlapping Sub-arrays Each With Target Sum Python O(n) O(n) Medium dp, PREFIX SUM HASH + BEST-SO-FAR DP, new, google imported
1478 Allocate Mailboxes Python O(n^2 * k) O(n^2) Hard dp, INTERVAL COST + PARTITION DP, new, google, amazon imported
1494 Parallel Courses II Python O(3^n) worst case O(2^n) Hard dp, BITMASK + BFS over subsets (n <= 15 -> state = set of taken courses), new, google imported
1504 Count Submatrices With All Ones Python O(m^2 * n) O(m * n) Medium dp, ROW WIDTH DP + ENUMERATE BOTTOM RIGHT CORNER, new, google, microsoft imported
1510 Stone Game IV Python O(n * sqrt(n)) O(n) Hard dp, GAME DP (win / lose states, bottom up), new, google, apple imported
1524 Number of Sub-arrays With Odd Sum Python O(n) O(1) Medium dp, PREFIX-SUM PARITY COUNTING, new, google, apple imported
1531 String Compression II Python O(n^2 * k) O(n * k) Hard dp, DP ON (index, deletions left), BUILDING ONE RUN AT A TIME, new, google, fb, microsoft, uber imported
1547 Minimum Cost to Cut a Stick Python O(m^3) O(m^2) Hard dp, INTERVAL DP (same shape as matrix-chain / burst balloons), new, google, amazon, fb imported
1548 The Most Similar Path in a Graph Python O(L * (n + m)) with L = len(targetPath) O(L * n) Hard dp, 🔒, DP OVER (step, city) + PARENT POINTERS TO REBUILD THE PATH, new, google imported
1553 Minimum Number of Days to Eat N Oranges Python O(log(n)^2) O(log(n)^2) Hard dp, MEMOIZED DFS (only n//2 and n//3 states are ever reachable), new, google, amazon imported
1563 Stone Game V Python O(n^2) O(n^2) Hard dp, INTERVAL DP + PREFIX MAX (O(n^2), the plain O(n^3) memo is too slow), new imported
1569 Number of Ways to Reorder Array to Get Same BST Python O(n^2) O(n^2) Hard dp, COMBINATORICS + DIVIDE & CONQUER (interleave the two subtrees), new, google, amazon imported
1575 Count All Possible Routes Python O(fuel * n^2) O(fuel * n) Hard dp, DP over (fuel left, city) – bottom up so no deep recursion, new imported
1594 Maximum Non Negative Product in a Matrix Python O(m * n) O(m * n) Medium dp, DP KEEPING BOTH MAX AND MIN (a negative cell flips the two), new, google, amazon imported
1595 Minimum Cost to Connect Two Groups of Points Python O(m * 2^n * n) O(m * 2^n) Hard dp, BITMASK DP over group 2 (size2 <= 12), new, google imported
1626 Best Team With No Conflicts Python O(n^2) O(n) Medium dp, SORT + LONGEST-INCREASING-SUBSEQUENCE style DP (max sum variant), new, uber imported
1639 Number of Ways to Form a Target String Given a Dictionary Python O(n * (L + m)) O(26 * n + m) with n = word len, m = len(target) Hard dp, DP over COLUMNS (which word we pick never matters, only the count), new, google, microsoft imported
1655 Distribute Repeating Integers Python O(k * 3^m) O(2^m) Hard dp, BITMASK DP OVER SUBSETS (m <= 10 customers, <= 50 distinct values), new, google imported
1664 Ways to Make a Fair Array Python O(n) O(1) Medium dp, PREFIX / SUFFIX PARITY SUMS (removing index i flips the parity of the tail), new imported
1681 Minimum Incompatibility Python O(2^n * n) for the cost table + subset-sum DP O(2^n) Hard dp, BITMASK DP OVER SUBSETS (n <= 16 -> partition into groups of size m = n/k), new imported
1682 Longest Palindromic Subsequence II Python O(n^2 * 26) O(n * 26) Medium dp, 🔒, INTERVAL DP WITH AN EXTRA “LAST PAIRED CHAR” DIMENSION, new imported
1690 Stone Game VII Python O(n^2) O(n) Medium dp, INTERVAL DP ON THE SCORE DIFFERENCE (zero-sum game -> one table, not two), new imported
1691 Maximum Height by Stacking Cuboids Python O(n^2) O(n) Hard dp, SORT EACH CUBOID + LIS-STYLE DP (rotation collapses to “sort the dims”), new, google imported
1692 Count Ways to Distribute Candies Python O(n * k) O(k) Hard dp, 🔒, STIRLING NUMBERS OF THE SECOND KIND (bags are indistinguishable), new, google imported
1745 Palindrome Partitioning IV Python O(n^2) O(n^2) Hard dp, INTERVAL DP PALINDROME TABLE + ENUMERATE THE TWO CUTS, new imported
1746 Maximum Subarray Sum After One Operation Python O(n) O(1) Medium dp, 🔒, KADANE WITH A STATE FLAG (0 = not squared yet, 1 = already squared), new imported
1751 Maximum Number of Events That Can Be Attended II Python O(n log n + n * k) O(n * k) Hard dp, DP + BINARY SEARCH (weighted interval scheduling, capped at k picks), new, amazon imported
1770 Maximum Score from Performing Multiplication Operations Python O(m^2) O(m) Hard dp, DP ON (operation index, how many were taken from the LEFT), new, google, amazon imported
1771 Maximize Palindrome Length From Subsequences Python O((n1 + n2)^2) O((n1 + n2)^2) Hard dp, LONGEST PALINDROMIC SUBSEQUENCE ON word1 + word2, WITH A CROSSING PAIR, new imported
1774 Closest Dessert Cost Python O(3^m + n * 3^m) O(3^m) Medium dp, ENUMERATE EVERY TOPPING COMBINATION (m <= 10 -> at most 3^10 sums), new, google imported
1787 Make the XOR of All Segments Equal to Zero Python O(n * 2^10 + k * 2^10) O(n + 2^10) Hard dp, DP OVER RESIDUE CLASSES i % k, STATE = RUNNING XOR (values < 2^10), new imported
1803 Count Pairs With XOR in a Range Python O(n * 15) O(n * 15) Hard dp, BINARY TRIE + PREFIX COUNTING (count(< high+1) - count(< low)), new imported
1857 Largest Color Value in a Directed Graph Python O((n + m) * 26) O(n * 26) Hard dp, TOPOLOGICAL SORT (KAHN) + DP OVER 26 COLORS, new, google, apple imported
1866 Number of Ways to Rearrange Sticks With K Sticks Visible Python O(n * k) O(k) Hard dp, DP (unsigned Stirling numbers of the FIRST kind), new, google imported
1872 Stone Game VIII Python O(n) O(n) for the prefix sums Hard dp, PREFIX SUM + SUFFIX DP (a move is just “pick a prefix boundary”), new imported
1883 Minimum Skips to Arrive at Meeting On Time Python O(n^2) O(n) Hard dp, DP ON (road index, skips used), MEASURED IN “DISTANCE UNITS”, new, google imported
1900 The Earliest and Latest Rounds Where Players Compete Python O(n^4 * log n) states x transitions (n <= 28, trivial in practice) O(n^3) memo entries Hard dp, MEMOISED SEARCH ON THE STATE (n, position of f, position of s), new, google imported
1908 Game of Nim Python O(n) O(1) Medium dp, 🔒, GAME THEORY / SPRAGUE-GRUNDY (this is classic Nim -> XOR “nim-sum”), new imported
1931 Painting a Grid With Three Different Colors Python O(3^(2m) + n * V^2) with V = number of valid columns O(V^2) Hard dp, BITMASK / BASE-3 STATE COMPRESSION DP OVER COLUMNS, new, google imported
1937 Maximum Number of Points with Cost Python O(m * n) O(n) Medium dp, ROW DP + PREFIX/SUFFIX MAX (split the abs() into two directions), new, google, amazon imported
1955 Count Number of Special Subsequences Python O(n) O(1) Hard dp, DP ON “WHICH BLOCK ARE WE IN” (3 rolling counters, one pass), new, amazon imported
1959 Minimum Total Space Wasted With K Resizing Operations Python O(n^2 * k) O(n^2 + n*k) Medium dp, PARTITION DP (k resizes == cut nums into k+1 segments), new imported
1960 Maximum Product of the Length of Two Palindromic Substrings Python O(n) O(n) Hard dp, MANACHER + PREFIX / SUFFIX BEST PALINDROME, new imported
1977 Number of Ways to Separate Numbers Python O(n^2) O(n^2) Hard dp, DP + PREFIX SUM OVER LAST-BLOCK LENGTH + LCP TABLE, new imported
1981 Minimize the Difference Between Target and Chosen Elements Python O(m * n * S / 64) with S = max total sum O(S) Medium dp, GROUPED KNAPSACK (reachable-sum bitset, one group per row), new, amazon imported
1986 Minimum Number of Work Sessions to Finish the Tasks Python O(3^n) O(2^n) Medium dp, BITMASK DP + SUBSET ENUMERATION, new imported
1987 Number of Unique Good Subsequences Python O(n) O(1) Hard dp, DP ON THE LAST CHARACTER (count DISTINCT strings, not positions), new, google imported
1994 The Number of Good Subsets Python O(30 * 2^10) O(2^10) Hard dp, BITMASK KNAPSACK OVER THE 10 PRIMES BELOW 30, new imported
1997 First Day Where You Have Been in All the Rooms Python O(n) O(n) Medium dp, DP ON “FIRST ARRIVAL DAY” (prefix invariant), new imported
2002 Maximum Product of the Length of Two Palindromic Subsequences Python O(3^n + 2^n * n) O(2^n) Medium dp, BITMASK ENUMERATION + SUBMASK ENUMERATION (n <= 12, so 2^n masks is tiny), new imported
2008 Maximum Earnings From Taxi Python O(n + m), m = len(rides) O(n + m) Medium dp, DP OVER THE ROAD POSITION (weighted interval scheduling on a line), new imported
2019 The Score of Students Solving Math Expression Python O(n^3 * V^2) with V bounded by 1001 in practice O(n^2 * V) Hard dp, INTERVAL DP (all possible parenthesizations) + CORRECT EVAL, new, fb imported
2031 Count Subarrays With More Ones Than Zeros Python O(n) O(n) Medium dp, 🔒, MAP 0 -> -1, THEN COUNT PAIRS WITH prefix[j] > prefix[i] (i < j), new, google imported
2044 Count Number of Maximum Bitwise-OR Subsets Python O(n * |distinct ORs|) O(|distinct ORs|) Medium dp, DP OVER REACHABLE OR VALUES (counts per OR value), new imported
2052 Minimum Cost to Separate Sentence Into Rows Python O(n^2) O(n), n = number of words Medium dp, 🔒, PREFIX SUM + BOTTOM-UP DP (word-break with squared slack cost), new imported
2060 Check if an Original String Exists Given Two Encoded Strings Python O(n * m * D), D = O(1000) O(n * m * D) Hard dp, MEMOISED DFS ON (i, j, diff) - “wildcard budget” matching, new, fb imported
2088 Count Fertile Pyramids in a Land Python O(m * n) O(m * n) Hard dp, DP ON “TALLEST PYRAMID WITH APEX HERE”, RUN TWICE (flip the grid), new, google imported
2140 Solving Questions With Brainpower Python O(n) O(n) Medium dp, SUFFIX DP — dp[i] = BEST SCORE ACHIEVABLE FROM QUESTION i ONWARDS, new imported
2143 Choose Numbers From Two Arrays in Range Python O(n * S) with S the span of possible differences O(S) Hard dp, 🔒, ROLLING DP OVER THE RUNNING DIFFERENCE, ALL STARTS AT ONCE, new imported
2167 Minimum Time to Remove All Cars Containing Illegal Goods Python O(n) O(n) Hard dp, PREFIX / SUFFIX DP AROUND A SPLIT POINT, new, google imported
2174 Remove All Ones With Row and Column Flips II Python O(2^(m*n) * m * n) O(2^(m*n)) Medium dp, 🔒, THE WHOLE GRID FITS IN 15 BITS -> BFS / MEMOISED SEARCH OVER STATES, new, google imported
2184 Number of Ways to Build Sturdy Brick Wall Python O(height * 2^width * width) O(2^width) Medium dp, 🔒, BITMASK DP OVER ROW “JOINT” PATTERNS + SUBSET-SUM TRANSFORM, new imported
2188 Minimum Time to Finish the Race Python O(m * 18 + numLaps * 18) O(numLaps) Hard dp, PRECOMPUTE “BEST STINT OF k LAPS”, THEN A 1D DP OVER THE LAPS, new imported
2189 Number of Ways to Build House of Cards Python O(n * sqrt(n)) O(n) Medium dp, 🔒, A ROW OF k TRIANGLES COSTS 3k - 1 CARDS, AND ROW SIZES ARE DISTINCT, new imported
2209 Minimum White Tiles After Covering With Carpets Python O(n * numCarpets) O(n * numCarpets) Hard dp, DP ON (PREFIX LENGTH, CARPETS USED), new imported
2218 Maximum Value of K Coins From Piles Python O(k * L), L = total number of coins O(k) Hard dp, GROUPED KNAPSACK DP (each pile is one “group”, pick a prefix of it), new imported
2222 Number of Ways to Select Buildings Python O(n) O(1) Medium dp, COUNTING BY THE MIDDLE BUILDING, new imported
2247 Maximum Cost of Trip With K Highways Python O(2^n * n^2) O(2^n * n) Hard dp, 🔒, BITMASK DP OVER (VISITED SET, CURRENT CITY) — A HAMILTONIAN-STYLE WALK, new imported
2266 Count Number of Texts Python O(n) O(n) Medium dp, DP ON EACH EQUAL-DIGIT RUN (tribonacci / tetranacci), multiply the runs, new imported
2267 Check if There Is a Valid Parentheses String Path Python O(m * n * (m + n) / 64) big-int word ops O(n * (m + n) / 64) Hard dp, DP OVER REACHABLE BALANCES, kept as a BITSET (one python int per cell), new imported
2291 Maximum Profit From Trading Stocks Python O(n * budget) O(budget) Medium dp, 🔒, 0/1 KNAPSACK — WEIGHT = present[i], VALUE = future[i] - present[i], new imported
2297 Jump Game VIII Python O(n) O(n) Medium dp, 🔒, EACH INDEX HAS AT MOST TWO OUTGOING JUMPS — FIND THEM WITH STACKS, new imported
2304 Minimum Path Cost in a Grid Python O(m * n^2) O(n) Medium dp, DP ROW BY ROW (dp[j] = cheapest path reaching row i, column j), new imported
2305 Fair Distribution of Cookies Python O(k * 3^n) O(2^n) Medium dp, BITMASK DP OVER SUBSETS (n <= 8, so 2^n masks are cheap), new imported
2312 Selling Pieces of Wood Python O(m * n * (m + n)) O(m * n) Hard dp, 2D INTERVAL DP (classic “cut a rod”, one dimension at a time), new imported
2313 Minimum Flips in Binary Tree to Get Result Python O(n) O(n) Hard dp, 🔒, TREE DP, 2 STATES PER NODE (cost to make it False / True), new imported
2318 Number of Distinct Roll Sequences Python O(n * 6^3) O(36) Hard dp, DP ON THE LAST TWO ROLLS (only a 6x6 state is needed), new imported
2320 Count Number of Ways to Place Houses Python O(n) O(1) Medium dp, FIBONACCI PER SIDE, THEN SQUARE (the two sides are independent), new imported
2327 Number of People Aware of a Secret Python O(n) O(n) Medium dp, DP ON “HOW MANY PEOPLE LEARN THE SECRET ON DAY i”, new imported
2328 Number of Increasing Paths in a Grid Python O(m * n log(m * n)) O(m * n) Hard dp, PROCESS THE CELLS IN ASCENDING VALUE ORDER — NO RECURSION NEEDED, new imported
2361 Minimum Costs Using the Train Line Python O(n) O(1) extra (O(n) for the answer) Hard dp, 🔒, DP WITH 2 STATES (which route we are standing on at each stop), new imported
2369 Check if There is a Valid Partition For The Array Python O(n) O(n) Medium dp, LINEAR DP ON PREFIX LENGTHS — ONLY BLOCKS OF SIZE 2 OR 3 EXIST, new imported
2370 Longest Ideal Subsequence Python O(26 * n) O(26) Medium dp, DP KEYED ON THE LAST LETTER, NOT ON THE INDEX, new imported
2378 Choose Edges to Maximize Score in a Tree Python O(n) O(n) Medium dp, 🔒, CLASSIC TREE MATCHING DP — TWO STATES PER NODE, new imported
2380 Time Needed to Rearrange a Binary String Python O(n) O(1) Medium dp, TRACK WHEN EACH ‘1’ FINISHES CROSSING THE ZEROS TO ITS LEFT, new imported
2403 Minimum Time to Kill All Monsters Python O(2^n * n) O(2^n) Hard dp, 🔒, BITMASK DP OVER WHICH MONSTERS ARE ALREADY DEAD, new imported
2420 Find All Good Indices Python O(n) O(n) Medium dp, TWO RUN-LENGTH ARRAYS, ONE FROM EACH DIRECTION, new imported
2430 Maximum Deletions on a String Python O(n^2) O(n) Hard dp, SUFFIX DP + ROLLING HASH FOR THE O(1) BLOCK COMPARISON, new imported
2431 Maximize Total Tastiness of Purchased Fruits Python O(n * maxAmount * maxCoupons) O(maxAmount * maxCoupons) Medium dp, 🔒, 0/1 KNAPSACK WITH A SECOND DIMENSION FOR THE COUPONS, new imported
2435 Paths in Matrix Whose Sum Is Divisible by K Python O(m * n * k) O(n * k) Hard dp, DP ON (cell, remainder) (carry the running sum modulo k as an extra state), new imported
2447 Number of Subarrays With GCD Equal to K Python O(n * log(max(nums)) * log(max(nums))) O(log(max(nums))) Medium dp, DP OVER “DISTINCT GCDs ENDING AT i” (a classic logarithmic-state trick), new imported
2463 Minimum Total Distance Traveled Python O(n * m * limit) O(n * m) Hard dp, SORT BOTH, THEN DP — AN OPTIMAL ASSIGNMENT NEVER CROSSES, new imported
2464 Minimum Subarrays in a Valid Split Python O(n^2 log(max)) O(n) Medium dp, 🔒, PREFIX DP OVER THE CUT POSITIONS, new imported
2466 Count Ways To Build Good Strings Python O(high) O(high) Medium dp, COUNT BY LENGTH — ONLY THE LENGTH MATTERS, NOT THE CONTENT, new imported
2470 Number of Subarrays With LCM Equal to K Python O(n^2 log(max)) O(1) Medium dp, EXTEND EACH START WHILE THE RUNNING LCM STILL DIVIDES k, new imported
2475 Number of Unequal Triplets in Array Python O(n) O(n) Easy dp, GROUP COUNTING (pick 3 DIFFERENT value-groups, order does not matter), new imported
2478 Number of Beautiful Partitions Python O(n * k) O(n * k) Hard dp, DP OVER CUT POSITIONS + PREFIX SUMS, new imported
2495 Number of Subarrays Having Even Product Python O(n) O(1) Medium dp, 🔒, DP (COUNT SUBARRAYS ENDING AT EACH INDEX) + LAST EVEN INDEX, new imported
2510 Check if There is a Path With Equal Number of 0’s And 1’s Python O(m * n * (m + n) / 64) O(n * (m + n) / 64) Medium dp, 🔒, DP + BITMASK (bitset of reachable “number of 1’s”), new imported
2518 Number of Great Partitions Python O(n * k) O(k) Hard dp, COMPLEMENTARY COUNTING + 0/1 KNAPSACK (count subsets with sum < k), new imported
2533 Number of Good Binary Strings Python O(maxLength) O(maxLength) Medium dp, 🔒, DP OVER “APPEND ONE WHOLE BLOCK”, new imported
2538 Difference Between Maximum and Minimum Price Sum Python O(n) O(n) Hard dp, TREE DP – BEST PATH WITH ONE ENDPOINT’S PRICE DROPPED, new imported
2547 Minimum Cost to Split an Array Python O(n^2) O(n) Hard dp, DP OVER SUFFIXES + INCREMENTAL “APPEARS ONCE” COUNTER, new imported
2552 Count Increasing Quadruplets Python O(n^2) O(n) Hard dp, DP OVER PAIRS (O(n^2) time, O(n) space), new imported
2565 Subsequence With the Minimum Score Python O((m + n) + n log n) O(n) Hard dp, PREFIX / SUFFIX GREEDY MATCH + BINARY SEARCH ON THE WINDOW LENGTH, new imported
2572 Count the Number of Square-Free Subsets Python O(n + 30 * 2^10) O(2^10) Medium dp, BITMASK DP OVER THE 10 PRIMES <= 30, new imported
2585 Number of Ways to Earn Points Python O(n * target * count) O(target) Hard dp, BOUNDED KNAPSACK DP (group / multiple knapsack), new imported
2597 The Number of Beautiful Subsets Python O(n log n) O(n) Medium dp, GROUP BY (value % k) -> HOUSE-ROBBER DP ON EACH CHAIN, new imported
2638 Count the Number of K-Free Subsets Python O(n * log(n)) O(n) Medium dp, 🔒, GROUP BY (value % k) -> CHAINS -> “HOUSE ROBBER” DP ON EACH CHAIN, new imported
2681 Power of Heroes Python O(n * log(n)) (dominated by the sort) O(1) extra Hard dp, SORT + RUNNING DP OVER “SUM OF WEIGHTED MAX^2”, new imported
2713 Maximum Strictly Increasing Cells in a Matrix Python O(m * n * log(m * n)) O(m * n) Hard dp, SORT BY VALUE + DP with PER-ROW / PER-COLUMN MAXIMA, new imported
2719 Count of Integers Python O(10 * n * max_sum) O(n * max_sum) (n = len(num2) <= 23) Hard dp, DIGIT DP (count [0, hi] then subtract via prefix difference), new imported
2742 Painting the Walls Python O(n^2) O(n) Hard dp, REPHRASE AS A 0/1 KNAPSACK (“BUY ENOUGH TIME TO COVER n WALLS”), new imported
2746 Decremental String Concatenation Python O(n * 26^2) O(26^2) Medium dp, DP OVER (FIRST CHAR, LAST CHAR) OF THE ACCUMULATED STRING, new imported
2770 Maximum Number of Jumps to Reach the Last Index Python O(n^2) O(n) Medium dp, LONGEST-PATH DP ON A DAG (jumps only go forward, so index order works), new imported
2771 Longest Non-decreasing Subarray From Two Arrays Python O(n) O(1) Medium dp, DP KEYED ON “WHICH ARRAY DID I TAKE AT i”, new imported
2786 Visit Array Positions to Maximize Score Python O(n) O(1) Medium dp, DP ON PARITY (2 ROLLING STATES), new imported
2787 Ways to Express an Integer as Sum of Powers Python O(n * n^(1/x)) O(n) Medium dp, 0/1 KNAPSACK (COUNT SUBSETS SUMMING TO n), new imported
2801 Count Stepping Numbers in Range Python O(L * 10 * 10) O(L * 10) L = len(high) <= 100 Hard dp, DIGIT DP (COUNT [1, high] - COUNT [1, low - 1]), new imported
2809 Minimum Time to Make Array Sum At Most x Python O(n^2) O(n) Hard dp, SORT BY nums2 + KNAPSACK-STYLE DP OVER “HOW MANY WE ZERO OUT”, new imported
2826 Sorting Three Groups Python O(n) O(1) Medium dp, DP (removals = n - longest non-decreasing subsequence), new imported
2827 Number of Beautiful Integers in the Range Python O(log(x) * k * d * 10) per bound O(log(x) * k * d) Hard dp, DIGIT DP + PREFIX SUBTRACTION, new imported
2830 Maximize the Profit as the Salesman Python O(n + m) O(n + m) Medium dp, DP OVER HOUSES (weighted interval scheduling, bucketed by end), new imported
2858 Minimum Edge Reversals So Every Node Is Reachable Python O(n) O(n) Hard dp, RE-ROOTING DP (TREE DP) ON THE UNDIRECTED TREE, new imported
2913 Subarrays Distinct Element Sum of Squares I Python O(n^2) O(n) Easy dp, BRUTE FORCE ENUMERATION + INCREMENTAL DISTINCT COUNT, new imported
3018 Maximum Number of Removal Queries That Can Be Processed I Python O(n^2) O(n^2) Hard dp, 🔒, DP OVER (TAKEN FROM THE LEFT, TAKEN FROM THE RIGHT), new imported
3020 Find the Maximum Number of Elements in Subset Python O(n log log max) O(n) Medium dp, WALK THE SQUARING CHAIN x, x^2, x^4, … AND SEE HOW FAR IT SURVIVES, new imported
3040 Maximum Number of Operations With the Same Score II Python O(n^2) O(n^2) Medium dp, ONLY 3 POSSIBLE SCORES — FIX ONE, THEN MEMOISED (l, r) SEARCH, new imported
3041 Maximize Consecutive Elements in an Array After Modification Python O(n log n) O(n) Hard dp, DP ON VALUES — EACH ELEMENT EXTENDS A RUN AS x OR AS x+1, new imported
3077 Maximum Strength of K Disjoint Subarrays Python O(n * k) O(n) Hard dp, DP OVER (SUBARRAYS USED, PREFIX LENGTH), WITH A “STILL OPEN” STATE, new imported
3082 Find the Sum of the Power of All Subsequences Python O(n * k) O(k) Hard dp, COUNT PAIRS (SUBSEQUENCE S, SUB-SUBSEQUENCE T OF S WITH SUM k), new imported
3098 Find the Sum of Subsequence Powers Python O(n^2 * n * k) = O(n^3 * k) worst case O(n * k) Hard dp, SUM THE MINIMUM BY LAYERS — count(power >= d) SUMMED OVER d, new imported
3101 Count Alternating Subarrays Python O(n) O(1) Medium dp, COUNT THE ALTERNATING SUBARRAYS ENDING AT EACH INDEX, new imported
3117 Minimum Sum of Values by Dividing Array Python O(n * m * 17) O(n) Hard dp, DP BY SEGMENT INDEX, CARRYING THE FEW DISTINCT SUFFIX-AND VALUES, new imported
3129 Find All Possible Stable Binary Arrays I Python O(zero * one) O(zero * one) Medium dp, “NO SUBARRAY LONGER THAN limit IS UNIFORM” == “NO RUN EXCEEDS limit”, new imported
3130 Find All Possible Stable Binary Arrays II Python O(zero * one) O(zero * one) Hard dp, SAME RECURRENCE AS LC 3129 — IT WAS ALREADY O(zero * one), new imported
3141 Maximum Hamming Distances Python O(m * 2^m) O(2^m) Hard dp, 🔒, FLIP THE QUESTION — FARTHEST FROM x IS NEAREST TO ~x, new imported
3144 Minimum Substring Partition of Equal Character Frequency Python O(n^2) O(n) Medium dp, DP OVER PREFIXES, EXTENDING THE LAST PIECE LEFTWARDS, new imported
3148 Maximum Difference Score in a Grid Python O(m * n) O(n) Medium dp, A MULTI-MOVE PATH TELESCOPES — ONLY THE ENDPOINTS MATTER, new imported
3149 Find the Minimum Cost Array Permutation Python O(2^n * n^2) O(2^n * n) Hard dp, HAMILTONIAN-CYCLE BITMASK DP, ANCHORED AT 0, new imported
3176 Find the Maximum Length of a Good Subsequence I Python O(n^2 * k) O(n * k) Medium dp, DP OVER (LAST INDEX TAKEN, CHANGES SPENT), new imported
3177 Find the Maximum Length of a Good Subsequence II Python O(n * k) O(n * k) Hard dp, DROP THE “WHICH EARLIER INDEX” LOOP — KEEP A BEST-PER-VALUE TABLE, new imported
3180 Maximum Total Reward Using Operations I Python O(n * max value) O(max value) Medium dp, REACHABLE-TOTALS DP, WITH THE VALUES TAKEN IN INCREASING ORDER, new imported
3181 Maximum Total Reward Using Operations II Python O(n * max / word size) O(max / word size) Hard dp, SAME REACHABILITY DP, BUT THE SET LIVES IN THE BITS OF ONE BIG INT, new imported
3186 Maximum Total Damage With Spell Casting Python O(n log n) O(n) Medium dp, GROUP EQUAL DAMAGES, THEN A “HOUSE ROBBER” DP OVER DISTINCT VALUES, new imported
3193 Count the Number of Inversions Python O(n * maxCnt) O(maxCnt) Hard dp, BUILD THE PERMUTATION LEFT TO RIGHT, COUNTING INVERSIONS AS THEY APPEAR, new imported
3197 Find the Minimum Area to Cover All Ones II Python O(m * n * (m + n) * …) — small for 30x30 O(m * n) Hard dp, THREE NON-OVERLAPPING RECTANGLES = TWO GUILLOTINE CUTS, SIX SHAPES, new imported
3201 Find the Maximum Length of Valid Subsequence I Python O(n) O(1) Medium dp, THE COMMON PARITY IS EITHER 0 OR 1 — SO THERE ARE ONLY TWO SHAPES, new imported
3202 Find the Maximum Length of Valid Subsequence II Python O(n * k) O(k) Medium dp, FIX THE COMMON SUM RESIDUE, THEN THE SEQUENCE OF RESIDUES IS FORCED, new imported
3209 Number of Subarrays With AND Value of K Python O(30 * n) O(30) Hard dp, THE ANDs OF ALL SUBARRAYS ENDING AT i FORM AT MOST ~30 DISTINCT VALUES, new imported
3212 Count Submatrices With Equal Frequency of X and Y Python O(m * n) O(m * n) Medium dp, “CONTAINS grid[0][0]” MEANS IT IS A PREFIX RECTANGLE, new imported
3213 Construct String with Minimum Cost Python O(n * distinct lengths) O(n + total word length) Hard dp, DP OVER PREFIXES, WITH A ROLLING HASH SO EACH WORD LENGTH IS O(1), new imported
3241 Time Taken to Mark All Nodes Python O(n) O(n) Hard dp, REROOTING — ONE DOWNWARD PASS, THEN PUSH THE ANSWER OUTWARDS, new imported
3253 Construct String with Minimum Cost (Easy) Python O(n * m * L) O(n) Medium dp, 🔒, DP OVER PREFIXES, TESTING EACH WORD AS THE LAST PIECE, new imported
3259 Maximum Energy Boost From Two Drinks Python O(n) O(1) Medium dp, TWO ROLLING DP CHAINS, ONE PER DRINK, new imported
3277 Maximum XOR Score Subarray Queries Python O(n^2 + q) O(n^2) Hard dp, THE XOR SCORE OBEYS A PASCAL-LIKE RECURRENCE, SO TABULATE IT, new imported
3283 Maximum Number of Moves to Kill All Pawns Python O(16 * 50^2 + 2^n * n^2) O(2^n * n) Hard dp, PRECOMPUTE KNIGHT DISTANCES, THEN A MINIMAX BITMASK DP, new imported
3287 Find the Maximum Sequence Value of Array Python O(n * k * 7 + n * 128^2) O(n * k) Hard dp, SPLIT AT EVERY CUT, TRACKING THE ACHIEVABLE ORs AS A 128-BIT SET, new imported
3290 Maximum Multiplication Score Python O(n) O(1) Medium dp, DP OVER “HOW MANY OF a HAVE BEEN MATCHED SO FAR”, new imported
3291 Minimum Number of Valid Strings to Form Target I Python O(|target| * max word length + total word length) O(total word length) Medium dp, LONGEST REACH PER START, THEN THE JUMP-GAME GREEDY, new imported
3292 Minimum Number of Valid Strings to Form Target II Python O(sum of word lengths + |words| * |target|) O(|target|) Hard dp, Z-FUNCTION PER WORD INSTEAD OF A TRIE WALK, new imported
3316 Find Maximum Removals From Source String Python O(n * m) O(m) Medium dp, DP OVER (SOURCE PREFIX, PATTERN PREFIX) MAXIMISING THE DELETIONS, new imported
3320 Count The Number of Winning Sequences Python O(n^2) O(n) Hard dp, DP OVER (ROUND, BOB’S LAST CREATURE, SCORE DIFFERENCE), new imported
3332 Maximum Points Tourist Can Earn Python O(k * n^2) O(n) Medium dp, DP OVER (DAY, CITY) — EVERY CITY IS A LEGAL START, new imported
3333 Find the Original Typed String II Python O(m * k) O(k) Hard dp, COUNT EVERYTHING, THEN SUBTRACT THE TOO-SHORT ONES WITH A DP, new imported
3335 Total Characters in String After Transformations I Python O(n + 26 * t) O(1) Medium dp, ONLY THE 26 LETTER COUNTS MATTER, NOT THE STRING ITSELF, new imported
3336 Find the Number of Subsequences With Equal GCD Python O(n * reachable states) O(reachable states) Hard dp, DP OVER THE PAIR OF RUNNING GCDs, WITH 0 STANDING FOR “STILL EMPTY”, new imported
3337 Total Characters in String After Transformations II Python O(26^3 log t + n) O(26^2) Hard dp, THE ROUND IS A LINEAR MAP ON THE 26 COUNTS — SO EXPONENTIATE IT, new imported
3343 Count Number of Balanced Permutations Python O(10 * slots * sum * max count) O(slots * sum) Hard dp, SPLIT THE MULTISET BETWEEN THE TWO POSITION CLASSES, THEN COUNT ARRANGEMENTS, new imported
3351 Sum of Good Subsequences Python O(n) O(n) Hard dp, PER-VALUE TALLIES OF “HOW MANY SUBSEQUENCES END HERE” AND “WHAT THEY SUM TO”, new imported
3352 Count K-Reducible Numbers Less Than N Python O(len(s)^2) O(len(s)^2) Hard dp, ONE STEP COLLAPSES x TO ITS POPCOUNT — SO GROUP BY POPCOUNT, new imported
3363 Find the Maximum Number of Fruits Collected Python O(n^2) O(n^2) Hard dp, THE DIAGONAL CHILD IS FORCED; THE OTHER TWO ARE MIRRORED DPs, new imported
3366 Minimum Array Sum Python O(n * op1 * op2) O(op1 * op2) Medium dp, DP OVER (INDEX, OPERATION-1 BUDGET LEFT, OPERATION-2 BUDGET LEFT), new imported
3372 Maximize the Number of Target Nodes After Connecting Trees I Python O(n^2 + m^2) O(n + m) Medium dp, COUNT WITHIN k IN TREE 1, WITHIN k-1 IN TREE 2, AND TAKE THE BEST BRIDGE, new imported
3381 Maximum Subarray Sum With Length Divisible by K Python O(n) O(k) Medium dp, PREFIX SUMS, KEEPING THE SMALLEST PREFIX PER INDEX RESIDUE, new imported
3393 Count Paths With the Given XOR Value Python O(m * n * 16) O(n * 16) Medium dp, GRID DP OVER THE 4-BIT XOR STATE, new imported
3409 Longest Subsequence With Decreasing Adjacent Difference Python O(n * V) with V = 301 O(V^2) Medium dp, DP KEYED ON (LAST VALUE, DIFFERENCE FLOOR) — VALUES ARE ONLY 1…300, new imported
3414 Maximum Score of Non-overlapping Intervals Python O(n log n) with a 4-fold constant O(n) Hard dp, SUFFIX DP OVER (INTERVAL, BUDGET), CARRYING THE WINNING INDEX SET, new imported
3418 Maximum Amount of Money Robot Can Earn Python O(m * n * 3) O(n * 3) Medium dp, GRID DP WITH THE NUMBER OF NEUTRALISATIONS USED AS A THIRD AXIS, new imported
3429 Paint House IV Python O(n) O(1) Medium dp, FOLD THE ROW IN HALF AND WALK BOTH ENDS INWARD TOGETHER, new imported
3434 Maximum Frequency After Subarray Operation Python O(n) O(max value) Medium dp, ONE KADANE PER CANDIDATE VALUE, ALL 50 RUN AT ONCE VIA AN OFFSET, new imported
3441 Minimum Cost Good Caption Python O(26 n) O(26 n) Hard dp, SUFFIX DP WITH TWO STATES, THEN A GREEDY LEX-SMALLEST REPLAY, new imported
3444 Minimum Increments for Target Multiples in an Array Python O(n * 3^t) with t <= 4 O(2^t) Hard dp, BITMASK DP OVER THE (AT MOST 4) TARGETS, new imported
3503 Longest Palindrome After Substring Concatenation I Python O(n^2 * m^2 * (n+m)) O(n+m) Medium dp, BRUTE FORCE OVER EVERY (SUBSTRING OF s, SUBSTRING OF t) PAIR, new imported
3504 Longest Palindrome After Substring Concatenation II Python O(n^2 + m^2 + n*m) O(n^2 + m^2) Hard dp, PEEL MATCHED OUTER PAIRS UNTIL ONE SIDE RUNS OUT, new imported
3505 Minimum Operations to Make Elements Within K Subarrays Equal Python O(n * log n + n * k) O(n) Hard dp, SLIDING WINDOW MEDIAN COST + DP OVER THE NUMBER OF PICKED WINDOWS, new imported
3509 Maximum Product of Subsequences With an Alternating Sum Equal to K Python O(n * P) bigint ops with P the reachable products O(P) Hard dp, DP KEYED ON (PARITY, PRODUCT), WITH THE SET OF SUMS AS A BITMASK, new imported
3524 Find X Value of Array I Python O(n * k) O(k) Medium dp, ROLLING RESIDUE HISTOGRAM OF ALL SUBARRAYS ENDING AT THE CURRENT INDEX, new imported
3525 Find X Value of Array II Python O(n * k + q * k * log n) O(n * k) Hard dp, SEGMENT TREE WHOSE NODE SUMMARISES ALL PREFIXES OF ITS SEGMENT, new imported
3530 Maximum Profit from Valid Topological Order in DAG Python O(n * 2^n) O(2^n) Hard dp, BITMASK DP OVER PROCESSED SETS, WITH A MEET-IN-THE-MIDDLE READY TABLE, new imported
3533 Concatenated Divisibility Python O(2^n * n) O(2^n) Hard dp, PRECOMPUTE THE REACHABLE REMAINDERS OF EVERY SUBSET, THEN PICK GREEDILY, new imported
3538 Merge Operations for Minimum Travel Time Python O(n^3 * k) O(n^2 * k) Hard dp, DP OVER (PREVIOUS KEPT SIGN, CURRENT KEPT SIGN, MERGES USED), new imported
3539 Find Sum of Array Product of Magical Sequences Python O(n * m^2 * k) O(m^2 * k) Hard dp, COUNT BY MULTIPLICITY PER INDEX, AND ADD 2^index WITH A RUNNING CARRY, new imported
3543 Maximum Weighted K-Edge Path Python O(k * E * t / 64) O(n * t / 64) Medium dp, LAYERED DP WHOSE STATE IS A BITSET OF THE ACHIEVABLE PATH SUMS, new imported
3544 Subtree Inversion Sum Python O(n * k) O(n * k) Hard dp, TREE DP ON THE DISTANCE SINCE THE LAST INVERTED ANCESTOR, new imported
3562 Maximum Profit from Trading Stocks with Discounts Python O(n * budget^2) worst case O(n * budget) Hard dp, TREE KNAPSACK WITH “DID MY BOSS BUY?” AS A SECOND STATE, new imported
3563 Lexicographically Smallest String After Adjacent Removals Python O(n^3) O(n^2) Hard dp, INTERVAL DP FOR “CAN VANISH” + SUFFIX DP FOR THE SMALLEST TAIL, new imported
3573 Best Time to Buy and Sell Stock V Python O(n * k) O(k) Medium dp, 3-STATE DP (IDLE / LONG OPEN / SHORT OPEN) INDEXED BY TRANSACTION COUNT, new imported
3574 Maximize Subarray GCD Score Python O(n^2 * log(max)) O(n) Hard dp, DOUBLING CAN ONLY LIFT THE GCD BY ONE FACTOR OF 2, new imported
3575 Maximum Good Subtree Score Python O(n log n * 2^10) O(n * 2^10) Hard dp, DIGIT-MASK KNAPSACK PER SUBTREE, REUSED VIA SMALL-TO-LARGE MERGING, new imported
3578 Count Partitions With Max-Min Difference at Most K Python O(n) O(n) Medium dp, DP OVER PREFIXES + SLIDING WINDOW OF FEASIBLE CUT POINTS, new imported
3579 Minimum Steps to Convert String with Operations Python O(n^3 + n^2 * |S|) O(n + |S|^2) Hard dp, PARTITION DP OVER SUBSTRINGS + GREEDY PAIRING OF MISMATCHES, new imported
3583 Count Special Triplets Python O(n) O(n) Medium dp, FIX THE MIDDLE INDEX AND MULTIPLY THE TWO SIDE COUNTS, new imported
3592 Inverse Coin Change Python O(n^2) O(n) Medium dp, REBUILD THE COIN-CHANGE DP LEFT TO RIGHT AND READ OFF MISSING COINS, new imported
3595 Once Twice Python O(n) O(1) Medium dp, 🔒, BIT-COUNT MOD 3, THEN SPLIT ON A BIT WHERE THE TWO ANSWERS DIFFER, new imported
3599 Partition Array to Minimize XOR Python O(k * n^2) O(n) Medium dp, DP OVER (NUMBER OF PARTS, PREFIX LENGTH), MINIMISING A RUNNING MAX, new imported
3603 Minimum Cost Path with Alternating Directions II Python O(m * n) O(n) Medium dp, GRID DP, WITH THE WAIT COST FOLDED ONTO THE CELL YOU LEAVE, new imported
3610 Minimum Number of Primes to Sum to Target Python O(n * min(m, pi(n))) O(n) Medium dp, 🔒, UNBOUNDED COIN CHANGE OVER THE FIRST M PRIMES, new imported
3615 Longest Palindromic Path in Graph Python O(2^n * n^2) O(2^n * n) Hard dp, BITMASK DP GROWING THE PALINDROME FROM BOTH ENDS INWARD, new imported
3628 Maximum Number of Subsequences After One Inserting Python O(n) O(1) Medium dp, COUNT “LCT” SUBSEQUENCES + TRY THE THREE USEFUL INSERTIONS, new imported
3647 Maximum Weight in Two Bags Python O(n * w1 * w2 / 64) O(w1 * w2 / 64) Medium dp, 🔒, TWO-DIMENSIONAL REACHABILITY (KNAPSACK OVER A PAIR OF LOADS), new imported
3651 Minimum Cost Path with Teleportations Python O(k * m * n * log(m * n)) O(m * n) Hard dp, ONE MONOTONE DP PER TELEPORT COUNT, LINKED BY A SUFFIX MINIMUM, new imported
3654 Minimum Sum After Divisible Sum Deletions Python O(n) O(k) Medium dp, PREFIX SUMS MOD k + “BEST dp SEEN AT THIS RESIDUE”, new imported
3661 Maximum Walls Destroyed by Robots Python O(n log n + m log m) O(n + m) Hard dp, SORT BY POSITION, DP OVER “WHICH WAY DID THE PREVIOUS ROBOT FIRE”, new imported
3665 Twisted Mirror Path Count Python O(m * n) O(n) Medium dp, DP ON FLOW THROUGH A CELL, SPLIT BY THE DIRECTION OF TRAVEL, new imported
3670 Maximum Product of Two Integers With No Common Bits Python O(2^B * B + n) with B = 20 (nums[i] <= 10^6) O(2^B) Medium dp, SUM-OVER-SUBSETS DP — BEST PARTNER FOR EVERY MASK, new imported
3685 Subsequence Sum After Capping Elements Python O(n * k / 64 + k log n) O(k / 64 + n) Medium dp, SPLIT AT THE CAP – UNTOUCHED ITEMS KEEP A DP, CAPPED ONES ARE COINS, new imported
3686 Number of Stable Subsequences Python O(n) O(1) Hard dp, DP ON (LAST PARITY, LENGTH OF THE CURRENT PARITY RUN), new imported

Geometry

# Title Solution Time Space Difficulty Note Status
1453 Maximum Number of Darts Inside of a Circular Dartboard Python O(n^3) O(1) Hard geometry, GEOMETRY - “the best circle can always be pushed onto 2 points”, new, fb imported
1515 Best Position for a Service Centre Python O(iters * n) O(1) Hard geometry, GRADIENT DESCENT (geometric median / Weber point), new, uber imported
1610 Maximum Number of Visible Points Python O(n log n) O(n) Hard geometry, POLAR ANGLES + SLIDING WINDOW ON A CIRCULAR SORTED ARRAY, new, google, amazon imported
1924 Erect the Fence II Python O(n) expected O(n) Hard geometry, 🔒, WELZL / RANDOMIZED INCREMENTAL MINIMUM ENCLOSING CIRCLE, new, google imported
1956 Minimum Time For K Virus Variants to Spread Python O(100 * 100 * n log n) O(n) Hard geometry, 🔒, ENUMERATE MEETING CELLS + k-TH SMALLEST MANHATTAN DISTANCE, new imported
2101 Detonate the Maximum Bombs Python O(n^3) worst case (n DFS over n^2 edges) O(n^2) Medium geometry, BUILD A DIRECTED REACHABILITY GRAPH, THEN DFS FROM EVERY BOMB, new, google imported

Graph

# Title Solution Time Space Difficulty Note Status
0924 Minimize Malware Spread Python, Java O(n^2 * a(n)) O(n) Hard graph, union find, pick the node in the largest single-infected component, new, google imported
0928 Minimize Malware Spread II Python, Java O(n^2 * a(n)) O(n^2) Hard graph, union find over clean nodes, count each infected node’s exclusive reach, new imported
1042 Flower Planting With No Adjacent Python O(n + e), e = len(paths) O(n + e) Medium graph, GREEDY GRAPH COLORING, new, google, fb imported
1101 The Earliest Moment When Everyone Become Friends Python O(m log m) O(n) Medium graph, 🔒, SORT by timestamp + UNION FIND (count components), new, google imported
1168 Optimize Water Distribution in a Village Python O((m + n) log (m + n)) O(m + n) Hard graph, 🔒, MST (KRUSKAL) + VIRTUAL NODE 0, new, google, fb, microsoft imported
1334 Find the City With the Smallest Number of Neighbors at a Threshold Distance Python O(n^3) O(n^2) Medium graph, FLOYD-WARSHALL (all pairs shortest path), new, apple, uber imported
1349 Maximum Students Taking Exam Python O(m * 4^n) O(2^n) Hard graph, BITMASK DP row by row (n <= 8 -> a row is one byte), new imported
1557 Minimum Number of Vertices to Reach All Nodes Python O(n + E) O(n) Medium graph, IN-DEGREE (a node with an incoming edge is reachable from elsewhere), new, google, amazon imported
1568 Minimum Number of Days to Disconnect Island Python O((m * n)^2) O(m * n) Hard graph, BRUTE FORCE + DFS (the answer is always 0, 1 or 2), new imported
1579 Remove Max Number of Edges to Keep Graph Fully Traversable Python O(E * alpha) O(n) Hard graph, UNION FIND x2 (add the shared type-3 edges first), new, uber imported
1601 Maximum Number of Achievable Transfer Requests Python O(2^m * m), m = len(requests) <= 16 O(n) Hard graph, BITMASK ENUMERATION (requests.length <= 16 -> 2^16 subsets), new, amazon imported
1615 Maximal Network Rank Python O(n^2 + E) O(n^2) Medium graph, DEGREE COUNT + INCLUSION-EXCLUSION over all pairs, new, amazon, microsoft imported
1627 Graph Connectivity With Threshold Python O(n log n * alpha(n) + q * alpha(n)) O(n) Hard graph, UNION FIND over multiples (sieve-style edge generation), new imported
1697 Checking Existence of Edge Length Limited Paths Python O((E + Q) log(E + Q)) dominated by the two sorts O(n + Q) Hard graph, OFFLINE QUERIES + UNION-FIND (sort both sides by weight, add edges once), new, google imported
1719 Number Of Ways To Reconstruct A Tree Python O(V^2 + E) O(V + E), V <= 500 Hard graph, DEGREE ORDERING + ADJACENCY SUBSET CHECK, new, uber imported
1724 Checking Existence of Edge Length Limited Paths II Python O(E log E) to build, O(log n) per query O(n) Hard graph, 🔒, PERSISTENT (VERSIONED) UNION FIND - queries arrive online, so LC 1697’s, new, google imported
1743 Restore the Array From Adjacent Pairs Python O(n) O(n) Medium graph, GRAPH IS A PATH - START AT A DEGREE-1 ENDPOINT AND WALK IT, new, uber imported
1778 Shortest Path in a Hidden Grid Python O(m * n) O(m * n) Medium graph, 🔒, DFS TO MAP THE HIDDEN GRID, THEN BFS ON THE MAP, new, google, fb imported
1782 Count Pairs Of Nodes Python O(m + n log n + Q * (n + m)) O(n + m) Hard graph, SORTED DEGREES + TWO POINTERS, THEN FIX UP THE SHARED EDGES, new, google, amazon imported
1786 Number of Restricted Paths From First to Last Node Python O((n + m) log n) O(n + m) Medium graph, DIJKSTRA FROM NODE n, THEN DP IN ORDER OF INCREASING DISTANCE, new, google imported
1810 Minimum Path Cost in a Hidden Grid Python O(mn log(mn)) O(m*n) Medium graph, 🔒, DFS TO EXPLORE (map the hidden grid) + DIJKSTRA ON THE MAP, new, google, fb imported
1820 Maximum Number of Accepted Invitations Python O(m * n * m) worst case (V * E) O(m + n) Medium graph, 🔒, MAXIMUM BIPARTITE MATCHING (Hungarian / Kuhn’s augmenting path), new imported
1879 Minimum XOR Sum of Two Arrays Python O(2^n * n) O(2^n) Hard graph, BITMASK DP (min-cost perfect matching on a tiny bipartite graph), new imported
1947 Maximum Compatibility Score Sum Python O(m^2 * n + 2^m * m) O(2^m) Medium graph, BITMASK DP OVER THE SET OF USED MENTORS (assignment problem, m <= 8), new, fb imported
2076 Process Restricted Friend Requests Python O(R * K * alpha(n)) O(n) Hard graph, UNION-FIND WITH A “DRY RUN” CHECK AGAINST EVERY RESTRICTION, new, google, fb imported
2077 Paths in Maze That Lead to Same Room Python O(E * n / 64) with set intersection O(V + E) Medium graph, 🔒, COUNT TRIANGLES BY INTERSECTING THE NEIGHBOUR SETS OF EACH EDGE, new, google imported
2092 Find All People With Secret Python O(m log m * alpha(n)) O(n) Hard graph, UNION-FIND PROCESSED IN TIME GROUPS, WITH A ROLLBACK PER GROUP, new, google, fb imported
2093 Minimum Cost to Reach City With Discounts Python O(E * D * log(V * D)) O(V * D) Medium graph, 🔒, DIJKSTRA ON THE EXPANDED STATE (city, discounts already used), new imported
2097 Valid Arrangement of Pairs Python O(V + E) O(V + E) Hard graph, EULERIAN PATH (Hierholzer) — each pair is a DIRECTED EDGE, new imported
2123 Minimum Operations to Remove Adjacent Ones in Matrix Python O(V * E) for Kuhn’s algorithm O(V + E) Hard graph, 🔒, MINIMUM VERTEX COVER ON A BIPARTITE GRAPH = MAXIMUM MATCHING (König), new, amazon imported
2127 Maximum Employees to Be Invited to a Meeting Python O(n) O(n) Hard graph, FUNCTIONAL GRAPH — EITHER ONE BIG CYCLE, OR ALL 2-CYCLES WITH TAILS, new imported
2172 Maximum AND Sum of Array Python O(2^(2*numSlots) * numSlots) O(2^(2*numSlots)) Hard graph, BITMASK DP OVER HALF-SLOTS (each slot split into two seats), new, google imported
2203 Minimum Weighted Subgraph With the Required Paths Python O((V + E) log V) O(V + E) Hard graph, THE OPTIMAL SUBGRAPH IS A “Y” — THREE DIJKSTRAS, ONE MEETING POINT, new imported
2204 Distance to a Cycle in Undirected Graph Python O(V + E) O(V + E) Hard graph, 🔒, PEEL THE TREES OFF (Kahn on degree 1), THEN MULTI-SOURCE BFS, new imported
2242 Maximum Score of a Node Sequence Python O(V + E log 3 + E * 9) O(V + E) Hard graph, ANCHOR ON THE MIDDLE EDGE, AND ONLY THE TOP-3 NEIGHBOURS CAN MATTER, new imported
2307 Check for Contradictions in Equations Python O(m * alpha(n)) O(n) Hard graph, 🔒, WEIGHTED UNION FIND (w[x] = value(x) / value(root(x))), new imported
2359 Find Closest Node to Given Two Nodes Python O(n) O(n) Medium graph, FUNCTIONAL GRAPH WALK (out-degree <= 1 -> the reachable set is one chain), new imported
2360 Longest Cycle in a Graph Python O(n) O(n) Hard graph, FUNCTIONAL GRAPH + VISIT TIMESTAMPS (each node walked once overall), new imported
2473 Minimum Cost to Buy Apples Python O(n * m * log m) O(n + m) Medium graph, 🔒, DIJKSTRA FROM EVERY START CITY (a round trip costs dist * (k + 1)), new imported
2608 Shortest Cycle in a Graph Python O(n * (n + m)) O(n + m) Hard graph, BFS FROM EVERY VERTEX (girth of an unweighted graph), new imported
2662 Minimum Cost of a Path With Special Roads Python O(n^2 * log n) O(n^2) worst case heap (n = #specialRoads) Medium graph, DIJKSTRA ON A TINY GRAPH (start + the <=200 special-road EXITS), new imported
2699 Modify Graph Edge Weights Python O(m * n^2) O(n^2) Hard graph, DIJKSTRA, ACTIVATING THE -1 EDGES ONE BY ONE (greedy), new imported
2714 Find Shortest Path with K Hops Python O(E * k * log(V * k)) O(n * k) Hard graph, 🔒, DIJKSTRA on the LAYERED STATE GRAPH (node, #hops used so far), new imported
2737 Find the Closest Marked Node Python O(E * log E) O(V + E) Medium graph, 🔒, DIJKSTRA (SINGLE SOURCE) + MIN OVER THE MARKED SET, new imported
2836 Maximize Value of Function in a Ball Passing Game Python O(n * log k) O(n * log k) Hard graph, BINARY LIFTING (a.k.a. sparse table on the functional graph), new imported
3108 Minimum Cost Walk in Weighted Graph Python O((n + E + Q) * alpha) O(n) Hard graph, A WALK MAY REUSE EDGES — SO IT CAN AND EVERY EDGE OF ITS COMPONENT, new imported
3243 Shortest Distance After Road Addition Queries I Python O(q * (n + q)) O(n + q) Medium graph, ALL EDGES COST 1 — SO ONE BFS PER QUERY IS ENOUGH AT THIS SIZE, new imported
3244 Shortest Distance After Road Addition Queries II Python O(n + q) O(n) Hard graph, THE NON-CROSSING GUARANTEE MAKES THE SHORTCUTS NEST, SO JUST SPLICE, new imported
3265 Count Almost Equal Pairs I Python O(n^2 * d^2) O(d) Medium graph, PAD TO A COMMON WIDTH, THEN TEST EVERY SINGLE SWAP, new imported
3267 Count Almost Equal Pairs II Python O(n * d^4) O(n) Hard graph, ENUMERATE EVERY STRING REACHABLE FROM x IN AT MOST TWO SWAPS, new imported
3276 Select Cells in Grid With Maximum Score Python O(distinct values * 2^m * m) O(2^m) Hard graph, BITMASK OVER THE ROWS, ITERATING THE DISTINCT VALUES, new imported
3310 Remove Methods From Project Python O(n + E) O(n + E) Medium graph, MARK THE REACHABLE SET FROM k, THEN CHECK FOR ANY EDGE INTO IT, new imported
3341 Find Minimum Time to Reach Last Room I Python O(n * m log(n * m)) O(n * m) Medium graph, DIJKSTRA WHERE THE EDGE COST DEPENDS ON THE ARRIVAL TIME, new imported
3342 Find Minimum Time to Reach Last Room II Python O(n * m log(n * m)) O(n * m) Medium graph, SAME DIJKSTRA, BUT THE STEP COST FOLLOWS THE CHESSBOARD PARITY, new imported
3376 Minimum Time to Break Locks I Python O(n! * n) O(n) Medium graph, n <= 8, SO TRY EVERY ORDER — THE COST OF AN ORDER IS FORCED, new imported
3377 Digit Operations to Make Two Integers Equal Python O(states * digits * 10 log states) O(states) Medium graph, DIJKSTRA OVER THE NUMBERS, WHERE ENTERING A STATE COSTS ITS VALUE, new imported
3378 Count Connected Components in LCM Graph Python O(threshold log threshold * alpha) O(threshold + n) Hard graph, GROUP BY COMMON MULTIPLE — EVERY DIVISOR OF L IS CONNECTED THROUGH L, new imported
3419 Minimize the Maximum Edge Weight of Graph Python O((V + E) log V) O(V + E) Medium graph, REVERSE THE EDGES, THEN RUN A MINIMAX (BOTTLENECK) DIJKSTRA FROM 0, new imported
3435 Frequencies of Shortest Supersequences Python O(2^V * V) with V <= 16 O(2^V) Hard graph, THE SCS DUPLICATES EXACTLY A “FEEDBACK VERTEX SET” OF THE ORDER GRAPH, new imported
3532 Path Existence Queries in a Graph I Python O(n + q) O(n) Medium graph, SORTED VALUES MAKE COMPONENTS CONTIGUOUS RUNS, new imported
3534 Path Existence Queries in a Graph II Python O((n + q) * log n) O(n * log n) Hard graph, SORT BY VALUE -> INTERVAL GRAPH -> GREEDY JUMPS VIA BINARY LIFTING, new imported
3536 Maximum Product of Two Digits Python O(d log d) with d <= 10 digits O(d) Easy graph, TAKE THE TWO LARGEST DIGITS, new imported
3547 Maximum Sum of Edge Values in a Graph Python O(n) O(1) Hard graph, THE GRAPH IS ONE PATH OR ONE CYCLE – BUILD THE ZIGZAG AROUND n, new imported
3594 Minimum Time to Transport All Individuals Python O(3^n * m * log(2^n * m)) O(3^n) Hard graph, DIJKSTRA OVER (CAMP BITMASK, STAGE, BOAT SIDE), new imported
3600 Maximize Spanning Tree Stability with Upgrades Python O(m * alpha(n) * log(M)) O(n) Hard graph, BINARY SEARCH THE STABILITY + UNION-FIND FEASIBILITY CHECK, new imported
3604 Minimum Time to Reach Destination in Directed Graph Python O((V + E) * log(V)) O(V + E) Medium graph, DIJKSTRA ON EARLIEST ARRIVAL TIME, new imported
3620 Network Recovery Pathways Python O((n + m) * log m) O(n + m) Hard graph, BINARY SEARCH THE SCORE + CHEAPEST PATH ON THE DAG, new imported
3650 Minimum Cost Path with Edge Reversals Python O((V + E) log V) O(V + E) Medium graph, MODEL THE REVERSAL AS A SECOND, PRICIER EDGE + DIJKSTRA, new imported
3656 Determine if a Simple Graph Exists Python O(n log n) O(n) Medium graph, 🔒, ERDOS-GALLAI THEOREM, new imported
3660 Jump Game IX Python O(n) O(n) Medium graph, THE JUMP RELATION IS THE (SYMMETRIC) INVERSION GRAPH, new imported

Greedy

# Title Solution Time Space Difficulty Note Status
0484 Find Permutation Python, Java O(n) O(n) Medium greedy, 🔒, reverse the D runs of the identity permutation, good trick, new, google imported
0630 Course Schedule III Python, Java O(nlogn) O(n) Hard greedy, sort by deadline + max-heap of durations, LC 1353, good trick, new, google, amazon, microsoft imported
0757 Set Intersection Size At Least Two Python, Java O(nlogn) O(1) Hard greedy, sort by end then greedily add the last two points, new, uber imported
0798 Smallest Rotation with Highest Score Python, Java O(n) O(n) Hard greedy, difference array over rotation scores, good trick, new, prefix sum imported
0843 Guess the Word Python, Java O(g * n^2 * l) O(n) Hard greedy, minimax guess against the worst-case bucket, interactive, new, array, math, string, google, amazon, fb, microsoft imported
0936 Stamping The Sequence Python, Java O(n * (n - m + 1)) O(n * (n - m + 1)) Hard greedy, reverse thinking, un-stamp back to ‘???’, good trick, new, google, fb imported
0991 Broken Calculator Python, Java O(log(target)) O(1) Medium greedy, work backwards from the target, halve when even, good trick, new imported
0995 Minimum Number of K Consecutive Bit Flips Python, Java O(n) O(n) Hard greedy, sliding window with a flip-difference array, good trick, new, bit manipulation, queue, google, amazon, fb, microsoft imported
1005 Maximize Sum Of Array After K Negations Python O(n log n) O(1), ignoring the sort Easy greedy, GREEDY + SORT, new, amazon imported
1029 Two City Scheduling Python O(n log n) O(1) Medium greedy, GREEDY + SORT ON (aCost - bCost), new, google, amazon, fb, apple, bloomberg imported
1053 Previous Permutation With One Swap Python O(n) O(1) Medium greedy, GREEDY (mirror of “next permutation”), new, amazon, fb, microsoft imported
1058 Minimize Rounding Error to Meet Target Python O(n log n) O(n) Medium greedy, 🔒, GREEDY + exact integer (thousandths) arithmetic, new imported
1090 Largest Values From Labels Python O(n log n) O(n) Medium greedy, GREEDY + SORT (big value first) + label counter, new, google imported
1111 Maximum Nesting Depth of Two Valid Parentheses Strings Python O(n) O(n) Medium greedy, GREEDY (split by DEPTH PARITY), new, fb, apple imported
1163 Last Substring in Lexicographical Order Python O(n) O(1) Hard greedy, TWO POINTERS, new imported
1183 Maximum Number of Ones Python O(width * height + L^2 log L) O(L^2) L = sideLength Hard greedy, 🔒, GREEDY over residue classes (the pattern must be periodic mod sideLength), new imported
1196 How Many Apples Can You Put into the Basket Python O(n log n) O(n) Easy greedy, 🔒, GREEDY (sort ascending, take the lightest apples first), new imported
1199 Minimum Time to Build Blocks Python O(n log n) O(n) Hard greedy, 🔒, GREEDY + MIN HEAP (reverse Huffman-style merging), new, google imported
1221 Split a String in Balanced Strings Python O(n) O(1) Easy greedy, GREEDY + RUNNING BALANCE, new, google, apple imported
1247 Minimum Swaps to Make Strings Equal Python O(n) O(1) Medium greedy, GREEDY / COUNTING, new, amazon, fb imported
1253 Reconstruct a 2-Row Binary Matrix Python O(n) O(1) Medium greedy, GREEDY (columns with sum 2 are forced ; sum 1 goes to the “richer” row), new imported
1282 Group the People Given the Group Size They Belong To Python O(n) O(n) Medium greedy, GREEDY + HASH MAP, new, apple imported
1326 Minimum Number of Taps to Open to Water a Garden Python O(n) O(n) Hard greedy, GREEDY / JUMP GAME II (interval covering reduced to minimum jumps), new, google, amazon, fb, apple imported
1338 Reduce Array Size to The Half Python O(n log n) O(n) Medium greedy, GREEDY + COUNTER, new, amazon imported
1354 Construct Target Array With Multiple Sums Python O(n log n log m) O(n) Hard greedy, REVERSE SIMULATION + MAX HEAP, new imported
1386 Cinema Seat Allocation Python O(m), m = len(reservedSeats) O(m) Medium greedy, hash map (row -> bitmask of reserved seats) + greedy, new, amazon, microsoft imported
1400 Construct K Palindrome Strings Python O(n) O(26) Medium greedy, GREEDY / PARITY COUNT (odd-count chars force separate palindromes), new, uber imported
1402 Reducing Dishes Python O(n log n) O(n) Hard greedy, GREEDY + SORTING, new imported
1403 Minimum Subsequence in Non-Increasing Order Python O(n log n) O(n) Easy greedy, GREEDY + SORTING, new, amazon imported
1414 Find the Minimum Number of Fibonacci Numbers Whose Sum Is K Python O(log k) O(log k) Medium greedy, GREEDY (Zeckendorf - always take the biggest Fibonacci <= k), new, google imported
1419 Minimum Number of Frogs Croaking Python O(n) O(1) Medium greedy, GREEDY COUNTING OF FROGS IN EACH STAGE, new imported
1432 Max Difference You Can Get From Changing an Integer Python O(d) O(d) Medium greedy, GREEDY, new imported
1433 Check If a String Can Break Another String Python O(n log n) O(n) Medium greedy, GREEDY + SORT, new imported
1488 Avoid Flood in The City Python O(n log n) O(n) Medium greedy, GREEDY + MIN-HEAP KEYED ON THE NEXT RAIN (dry the most urgent lake), new, google imported
1518 Water Bottles Python O(numBottles / numExchange) O(1) Easy greedy, SIMULATION (each trade consumes numExchange - 1 bottles net), new imported
1520 Maximum Number of Non-Overlapping Substrings Python O(26 * n) O(n) Hard greedy, SMALLEST VALID INTERVAL PER LETTER + GREEDY BY EARLIEST END, new, amazon imported
1526 Minimum Number of Increments on Subarrays to Form a Target Array Python O(n) O(1) Hard greedy, GREEDY / SUM OF POSITIVE RISES, new, google imported
1536 Minimum Swaps to Arrange a Binary Grid Python O(n^2) O(n) Medium greedy, REDUCE EACH ROW TO ITS TRAILING-ZERO COUNT, THEN GREEDY BUBBLING, new imported
1578 Minimum Time to Make Rope Colorful Python O(n) O(1) Medium greedy, GREEDY (inside a block of equal colours keep the most expensive one), new, apple, microsoft imported
1580 Put Boxes Into the Warehouse II Python O(n log n + b log b) O(n) Medium greedy, 🔒, PREFIX/SUFFIX MIN + GREEDY (a room is reachable from the better side), new, google imported
1585 Check If String Is Transformable With Substring Sort Operations Python O(10 * n) O(n) Hard greedy, GREEDY + QUEUE PER DIGIT (a sort = bubbling a digit left past bigger ones), new, google imported
1589 Maximum Sum Obtained of Any Permutation Python O(n log n + q) O(n) Medium greedy, DIFFERENCE ARRAY + GREEDY (biggest number on the hottest index), new imported
1591 Strange Printer II Python O(C * m * n) O(m * n + C^2), C <= 60 colours Hard greedy, BOUNDING BOX + TOPOLOGICAL SORT (colour a must be printed before b), new, google imported
1599 Maximum Profit of Operating a Centennial Wheel Python O(n + total_customers / 4) O(1) Medium greedy, SIMULATION (profit is only ever checked right after a rotation), new imported
1605 Find Valid Matrix Given Row and Column Sums Python O(m * n) O(1) extra (besides the output) Medium greedy, GREEDY (fill each cell with as much as it can possibly take), new, google imported
1616 Split Two Strings to Make Palindrome Python O(n) O(n) for the slice comparisons Medium greedy, GREEDY TWO POINTERS (match the outside as far as possible, then, new, google imported
1632 Rank Transform of a Matrix Python O(m * n * log(m * n)) O(m * n) Hard greedy, PROCESS VALUES IN INCREASING ORDER + UNION FIND on rows/cols, new, google imported
1653 Minimum Deletions to Make String Balanced Python O(n) O(1) Medium greedy, RUNNING DP – keep the best cost for the prefix seen so far, new, microsoft imported
1663 Smallest String With A Given Numeric Value Python O(n) O(n) Medium greedy, GREEDY FROM THE BACK (keep the prefix as small as possible), new imported
1665 Minimum Initial Energy to Finish Tasks Python O(n log n) O(n) for the sort Hard greedy, GREEDY + EXCHANGE-ARGUMENT SORT (do the biggest “slack” tasks LAST), new imported
1673 Find the Most Competitive Subsequence Python O(n) O(k) Medium greedy, MONOTONIC (INCREASING) STACK + FEASIBILITY GUARD, new, google, amazon imported
1674 Minimum Moves to Make Array Complementary Python O(n + limit) O(limit) Medium greedy, DIFFERENCE ARRAY / LINE SWEEP over every candidate target sum T, new imported
1686 Stone Game VI Python O(n log n) O(n) Medium greedy, GREEDY, SORT BY a[i] + b[i] DESCENDING (exchange argument), new imported
1689 Partitioning Into Minimum Number Of Deci-Binary Numbers Python O(len(n)) O(1) Medium greedy, GREEDY / MAX DIGIT (each deci-binary number contributes at most 1 per column), new imported
1702 Maximum Binary String After Change Python O(n) O(n) Medium greedy, GREEDY / INVARIANT (op 2 gathers the zeros, op 1 then eats all but one), new imported
1705 Maximum Number of Eaten Apples Python O((n + M) * log n), M = max(days) O(n) Medium greedy, GREEDY + MIN HEAP (always eat the batch that rots soonest), new, uber imported
1708 Largest Subarray Length K Python O(n) O(1) excluding the output Easy greedy, 🔒, GREEDY (all values are DISTINCT -> the first element decides everything), new, google imported
1717 Maximum Score From Removing Substrings Python O(n) O(1) Medium greedy, GREEDY + STACK COUNTERS (strip the higher-paying pair first), new, google imported
1725 Number Of Rectangles That Can Form The Largest Square Python O(n) O(1) Easy greedy, RUNNING MAX + COUNT (single pass, no sorting), new imported
1727 Largest Submatrix With Rearrangements Python O(m * n * log n) O(n) (heights kept one row at a time) Medium greedy, COLUMN HISTOGRAM + SORT EACH ROW (columns may be permuted freely), new, google imported
1733 Minimum Number of People to Teach Python O(k * L + |S| * L), k = len(friendships) O(m * L) Medium greedy, GREEDY / COUNTING (only BROKEN friendships matter, then pick the best language), new imported
1736 Latest Time by Replacing Hidden Digits Python O(1) O(1) Easy greedy, GREEDY, DIGIT BY DIGIT (earlier digits dominate the value), new, google imported
1737 Change Minimum Characters to Satisfy One of Three Conditions Python O(m + n + 26) O(26) Medium greedy, LETTER COUNTS + ENUMERATE THE 26 SPLIT POINTS, new, google imported
1749 Maximum Absolute Sum of Any Subarray Python O(n) O(1) Medium greedy, KADANE TWICE (max subarray sum AND min subarray sum), new, amazon imported
1754 Largest Merge Of Two Strings Python O((m + n) * (m + n)) O(m + n) Medium greedy, GREEDY WITH SUFFIX COMPARISON (take from the lexicographically bigger tail), new imported
1758 Minimum Changes To Make Alternating Binary String Python O(n) O(1) Easy greedy, COUNTING (there are only two possible alternating targets), new imported
1759 Count Number of Homogenous Substrings Python O(n) O(1) Medium greedy, GROUP CONSECUTIVE RUNS (a run of length L holds L * (L + 1) / 2 substrings), new imported
1762 Buildings With an Ocean View Python O(n) O(1) extra (output excluded) Medium greedy, 🔒, RIGHT TO LEFT SCAN (keep the tallest building seen so far on the right), new, google, amazon, fb, microsoft imported
1764 Form Array by Concatenating Subarrays of Another Array Python O(len(nums) * sum(len(groups[i]))) O(1) Medium greedy, GREEDY TWO POINTERS (match each group at its earliest possible position), new, amazon imported
1769 Minimum Number of Operations to Move All Balls to Each Box Python O(n) O(n) Medium greedy, PREFIX SUM IN BOTH DIRECTIONS (cost from the left + cost from the right), new, google, amazon imported
1775 Equal Sum Arrays With Minimum Number of Operations Python O(n + m) with counting sort over gains 0…5 O(1) Medium greedy, GREEDY ON THE “GAIN” OF EACH SINGLE CHANGE, new imported
1785 Minimum Elements to Add to Form a Given Sum Python O(n) O(1) Medium greedy, GREEDY (every added element moves the sum by at most limit), new imported
1788 Maximize the Beauty of the Garden Python O(n) O(n) Hard greedy, 🔒, FIRST OCCURRENCE + PREFIX SUM OF POSITIVE VALUES, new, amazon imported
1793 Maximum Score of a Good Subarray Python O(n) O(1) Hard greedy, TWO POINTERS EXPANDING OUT OF k (greedily keep the larger side), new, google, uber imported
1798 Maximum Number of Consecutive Values You Can Make Python O(n log n) O(1) Medium greedy, GREEDY ON SORTED COINS (keep the reachable prefix [0, res - 1]), new imported
1801 Number of Orders in the Backlog Python O(n log n) O(n) Medium greedy, TWO HEAPS SIMULATING AN ORDER BOOK, new, amazon imported
1815 Maximum Number of Groups Getting Fresh Donuts Python O(b * prod(cnt_i + 1) * b), b = batchSize O(b * prod(cnt_i + 1)) Hard greedy, STATE-COMPRESSION DP OVER REMAINDER COUNTS (order matters only via, new, google imported
1824 Minimum Sideway Jumps Python O(n) O(1) Medium greedy, ROLLING DP OVER 3 LANES (f[j] = min side jumps to stand on lane j+1, new imported
1827 Minimum Operations to Make the Array Increasing Python O(n) O(1) Easy greedy, GREEDY LEFT -> RIGHT (keep every element as small as legally possible), new, apple imported
1833 Maximum Ice Cream Bars Python O(n + M) O(M) Medium greedy, GREEDY (buy cheapest first) IMPLEMENTED WITH COUNTING SORT, new imported
1840 Maximum Building Height Python O(m log m), m = len(restrictions) O(m) Hard greedy, TIGHTEN THE RESTRICTIONS BOTH WAYS, THEN PEAK BETWEEN NEIGHBOURS, new imported
1842 Next Palindrome Using Same Digits Python O(n) O(n) Hard greedy, 🔒, NEXT PERMUTATION OF THE FIRST HALF ONLY, THEN MIRROR, new, amazon imported
1850 Minimum Adjacent Swaps to Reach the Kth Smallest Number Python O(k*n + n^2) O(n) Medium greedy, APPLY NEXT-PERMUTATION k TIMES, THEN GREEDY BUBBLE COUNT, new, google imported
1864 Minimum Number of Swaps to Make the Binary String Alternating Python O(n) O(1) Medium greedy, GREEDY / COUNTING (only 2 target patterns exist), new, google imported
1874 Minimize Product Sum of Two Arrays Python O(n log n) O(n) for the sorted copies Medium greedy, 🔒, GREEDY / REARRANGEMENT INEQUALITY (pair smallest with largest), new, google imported
1881 Maximum Value after Insertion Python O(len(n)) O(len(n)) for the result string Medium greedy, GREEDY (insert at the FIRST position that improves the digit), new, microsoft imported
1887 Reduction Operations to Make the Array Elements Equal Python O(n log n) O(n) for the sorted copy Medium greedy, SORT + COUNT DISTINCT LEVELS BELOW EACH ELEMENT, new imported
1893 Check if All the Integers in a Range Are Covered Python O(n + M), M = 52 O(M) Easy greedy, DIFFERENCE ARRAY (values are bounded by 50), new imported
1894 Find the Student that Will Replace the Chalk Python O(n) O(1) Medium greedy, MODULO THE FULL ROUND, THEN ONE LINEAR SCAN, new imported
1897 Redistribute Characters to Make All Strings Equal Python O(L), L = total number of characters O(1), at most 26 counters Easy greedy, COUNTING (characters are conserved, so each total must split evenly), new imported
1911 Maximum Alternating Subsequence Sum Python O(n) O(1) Medium greedy, DP ON PARITY OF THE PICKED LENGTH (2 rolling states, “stock trading” shape), new, amazon imported
1913 Maximum Product Difference Between Two Pairs Python O(n) O(1) Easy greedy, GREEDY (all values are positive -> take the 2 largest & the 2 smallest), new imported
1921 Eliminate Maximum Number of Monsters Python O(n log n) O(n) Medium greedy, GREEDY + SORT BY DEADLINE (classic “shoot the most urgent first”), new, google imported
1927 Sum Game Python O(n) O(1) Medium greedy, GAME THEORY / CASE ANALYSIS (closed form, no simulation), new imported
1936 Add Minimum Number of Rungs Python O(n) O(1) Medium greedy, GREEDY, GAP BY GAP (closed form per gap, no simulation), new imported
1946 Largest Number After Mutating Substring Python O(n) O(n) Medium greedy, GREEDY - START AT THE FIRST IMPROVABLE DIGIT, STOP AT THE FIRST LOSS, new imported
1953 Maximum Number of Weeks for Which You Can Work Python O(n) O(1) Medium greedy, GREEDY / “TASK REARRANGEMENT” BOUND (only the biggest project matters), new, amazon imported
1975 Maximum Matrix Sum Python O(n^2) O(1) Medium greedy, GREEDY / PARITY INVARIANT, new imported
2027 Minimum Moves to Convert String Python O(n) O(1) Easy greedy, GREEDY LEFT-TO-RIGHT SCAN, new imported
2030 Smallest K-Length Subsequence With Occurrences of a Letter Python O(n) O(k) Hard greedy, MONOTONIC STACK (“remove k digits” greedy) + A QUOTA FOR letter, new, google imported
2036 Maximum Alternating Subarray Sum Python O(n) O(1) Medium greedy, 🔒, KADANE WITH TWO STATES (the sign the NEXT element would carry), new, amazon imported
2037 Minimum Number of Moves to Seat Everyone Python O(n log n) O(n) Easy greedy, SORT BOTH, MATCH IN ORDER (rearrangement / exchange argument), new imported
2071 Maximum Number of Tasks You Can Assign Python O((n log n) + (m log m) + (n + m) log(min(n, m))) O(m) Hard greedy, BINARY SEARCH ON THE ANSWER k + GREEDY FEASIBILITY WITH A DEQUE, new, fb imported
2086 Minimum Number of Food Buckets to Feed the Hamsters Python O(n) O(n) Medium greedy, GREEDY — ALWAYS PREFER THE BUCKET ON THE RIGHT OF A HOUSE, new imported
2087 Minimum Cost Homecoming of a Robot in a Grid Python O(m + n) O(1) Medium greedy, THE COST IS PATH-INDEPENDENT — JUST WALK STRAIGHT THERE, new imported
2136 Earliest Possible Day of Full Bloom Python O(n log n) O(n) Hard greedy, PLANT THE SLOWEST-GROWING SEEDS FIRST (exchange argument), new imported
2139 Minimum Moves to Reach Target Score Python O(log target) O(1) Medium greedy, WORK BACKWARDS FROM target — HALVE WHENEVER YOU CAN, new imported
2141 Maximum Running Time of N Computers Python O(m log(total / n)) O(1) Hard greedy, BINARY SEARCH ON THE RUNTIME t + A CAPPED-SUM FEASIBILITY TEST, new imported
2144 Minimum Cost of Buying Candies With Discount Python O(n log n) O(n) Easy greedy, SORT DESCENDING, SKIP EVERY THIRD CANDY, new imported
2147 Number of Ways to Divide a Long Corridor Python O(n) O(n) Hard greedy, PAIR UP THE SEATS, MULTIPLY THE GAPS BETWEEN CONSECUTIVE PAIRS, new imported
2160 Minimum Sum of Four Digit Number After Splitting Digits Python O(1) O(1) Easy greedy, SORT THE DIGITS AND DEAL THEM ALTERNATELY INTO TWO 2-DIGIT NUMBERS, new, amazon imported
2165 Smallest Value of the Rearranged Number Python O(d log d) O(d) Medium greedy, SIGN DECIDES THE SORT DIRECTION; ZEROS ONLY MATTER WHEN POSITIVE, new imported
2178 Maximum Split of Positive Even Integers Python O(sqrt(finalSum)) O(sqrt(finalSum)) for the output Medium greedy, GREEDY (take the smallest unused even number as long as we can), new, google imported
2182 Construct String With Repeat Limit Python O(n + 26^2) O(n) Medium greedy, GREEDY + COUNTING (emit the largest letter, break runs with the next largest), new imported
2193 Minimum Number of Moves to Make Palindrome Python O(n^2) O(n) Hard greedy, GREEDY FROM THE OUTSIDE IN — MATCH s[i] WITH THE RIGHTMOST TWIN, new imported
2195 Append K Integers With Minimal Sum Python O(n log n) O(n) Medium greedy, WALK THE GAPS BETWEEN THE SORTED DISTINCT VALUES, SUMMING WITH GAUSS, new imported
2207 Maximize Number of Subsequences in a String Python O(n) O(1) Medium greedy, COUNT PAIRS IN ONE SWEEP, THEN CHOOSE THE BETTER SINGLE INSERTION, new imported
2214 Minimum Health to Beat Game Python O(n) O(1) Medium greedy, 🔒, SPEND THE SHIELD ON THE BIGGEST HIT — IT ONLY DEPENDS ON THE TOTAL, new imported
2216 Minimum Deletions to Make Array Beautiful Python O(n) O(1) Medium greedy, GREEDY LEFT-TO-RIGHT PAIRING, THEN FIX THE PARITY AT THE END, new imported
2224 Minimum Number of Operations to Convert Time Python O(1) O(1) Easy greedy, GREEDY (the coin system 1, 5, 15, 60 is canonical -> take the biggest first), new imported
2259 Remove Digit From Number to Maximize Result Python O(n) O(n) Easy greedy, GREEDY (all candidates have the same length -> compare left to right), new imported
2263 Make Array Non-decreasing or Non-increasing Python O(n log n) O(n) Hard greedy, 🔒, SLOPE TRICK / MAX-HEAP (isotonic L1 regression), new imported
2268 Minimum Number of Keypresses Python O(n + 26 log 26) O(26) Medium greedy, 🔒, GREEDY (exchange argument - cheapest slots go to the most frequent letters), new imported
2285 Maximum Total Importance of Roads Python O(n log n + len(roads)) O(n) Medium greedy, THE TOTAL IS sum(value[city] * degree[city]) — SO PAIR BIG WITH BIG, new imported
2294 Partition Array Such That Maximum Difference Is K Python O(n log n) O(n) Medium greedy, ORDER IS IRRELEVANT — SORT, THEN GREEDILY EXTEND EACH GROUP, new imported
2311 Longest Binary Subsequence Less Than or Equal to K Python O(n) O(1) Medium greedy, GREEDY FROM THE RIGHT (every ‘0’ is free, take cheap '1’s first), new imported
2321 Maximum Score Of Spliced Array Python O(n) O(1) Hard greedy, THE SWAP’S EFFECT IS A SUBARRAY SUM OF THE DIFFERENCE — KADANE, new imported
2323 Find Minimum Time to Finish All Jobs II Python O(n log n) O(n) Medium greedy, 🔒, SORT BOTH AND PAIR IN ORDER (rearrangement / exchange argument), new imported
2340 Minimum Adjacent Swaps to Make a Valid Array Python O(n) O(1) Medium greedy, 🔒, MOVE THE FIRST MINIMUM LEFT AND THE LAST MAXIMUM RIGHT — COUNT THE HOPS, new imported
2366 Minimum Replacements to Sort the Array Python O(n) O(1) Hard greedy, GREEDY RIGHT-TO-LEFT (split each value into as few parts as possible, new imported
2371 Minimize Maximum Value in a Grid Python O(m * n log(m * n)) O(m * n) Hard greedy, 🔒, ASSIGN VALUES IN INCREASING ORDER, EACH AS SMALL AS ITS ROW/COLUMN ALLOWS, new imported
2375 Construct Smallest Number From DI String Python O(n) O(n) Medium greedy, PUSH 1, 2, 3, … ON A STACK AND FLUSH IT AT EVERY ‘I’, new imported
2383 Minimum Hours of Training to Win a Competition Python O(n) O(1) Easy greedy, THE TWO RESOURCES ARE INDEPENDENT — COST THEM SEPARATELY, new imported
2384 Largest Palindromic Number Python O(n) O(n) Medium greedy, BUILD THE LEFT HALF GREEDILY FROM ‘9’ DOWN, THEN PICK A CENTRE, new imported
2405 Optimal Partition of String Python O(n) O(26) Medium greedy, EXTEND THE CURRENT PIECE AS FAR AS POSSIBLE, CUT ON THE FIRST REPEAT, new imported
2410 Maximum Matching of Players With Trainers Python O(n log n + m log m) O(n + m) Medium greedy, SORT BOTH, THEN A GREEDY TWO-POINTER SWEEP, new imported
2412 Minimum Money Required Before Transactions Python O(n) O(1) Hard greedy, WORST ORDER = ALL THE LOSSES FIRST, THEN THE HARDEST REMAINING ONE, new imported
2417 Closest Fair Integer Python O(gap * digits) O(digits) Medium greedy, 🔒, A FAIR NUMBER MUST HAVE AN EVEN DIGIT COUNT — JUMP OVER ODD LENGTHS, new imported
2422 Merge Operations to Turn Array Into a Palindrome Python O(n) O(n) Medium greedy, 🔒, TWO POINTERS, ALWAYS MERGE ON THE SMALLER SIDE, new imported
2434 Using a Robot to Print the Lexicographically Smallest String Python O(n) O(n) Medium greedy, STACK + SUFFIX MINIMUM — POP WHILE THE TOP CANNOT BE BEATEN, new imported
2436 Minimum Split Into Subarrays With GCD Greater Than One Python O(n * log(max(nums))) O(1) Medium greedy, 🔒, GREEDY + RUNNING GCD (extend the current piece as long as gcd stays > 1), new imported
2439 Minimize Maximum of Array Python O(n) O(1) Medium greedy, GREEDY / PREFIX AVERAGE (value can only ever move LEFT), new imported
2440 Create Components With Same Value Python O(n * d(s)), d(s) = number of divisors of s O(n) Hard greedy, ENUMERATE THE DIVISOR + GREEDY BOTTOM-UP PACKING, new imported
2449 Minimum Number of Operations to Make Arrays Similar Python O(n log n) O(n) Hard greedy, GREEDY MATCH WITHIN EACH PARITY CLASS, new imported
2457 Minimum Addition to Make Integer Beautiful Python O(digits^2) O(1) Medium greedy, CLEAR THE TRAILING DIGITS ONE PLACE AT A TIME, new imported
2459 Sort Array by Moving Items to Empty Space Python O(n) O(n) Hard greedy, 🔒, PERMUTATION CYCLES — THE HOLE RIDES ONE OF THEM FOR FREE, new imported
2472 Maximum Number of Non-overlapping Palindrome Substrings Python O(n^2) O(n) Hard greedy, INTERVAL SCHEDULING — TAKE THE PALINDROME THAT ENDS EARLIEST, new imported
2479 Maximum XOR of Two Non-Overlapping Subtrees Python O(n * B) O(n * B), B = 46 bits Hard greedy, 🔒, SUBTREE SUMS + BINARY TRIE, QUERY ON ENTRY / INSERT ON EXIT, new imported
2483 Minimum Penalty for a Shop Python O(n) O(1) Medium greedy, SWEEP THE CLOSING HOUR, UPDATING THE PENALTY INCREMENTALLY, new imported
2486 Append Characters to String to Make Subsequence Python O(len(s) + len(t)) O(1) Medium greedy, GREEDY TWO-POINTER MATCH — WHATEVER OF t IS LEFT MUST BE APPENDED, new imported
2498 Frog Jump II Python O(n) O(1) Medium greedy, GREEDY (SPLIT INTO 2 ALTERNATING PATHS), new imported
2499 Minimum Total Cost to Make Arrays Unequal Python O(n) O(n) Hard greedy, GREEDY (MANDATORY INDICES + DOMINANT VALUE) + COUNTER, new imported
2522 Partition String Into Substrings With Values at Most K Python O(n) O(1) Medium greedy, GREEDY (extend the current piece as far as it can legally go), new imported
2541 Minimum Operations to Make Array Equal II Python O(n) O(1) Medium greedy, GREEDY / COUNTING (every op moves exactly k from one slot to another), new imported
2548 Maximum Price to Fill a Bag Python O(n * log n) O(n) for the sorted copy Medium greedy, 🔒, GREEDY (fractional knapsack — take the best price-per-weight first), new imported
2551 Put Marbles in Bags Python O(n log n) O(n) Hard greedy, GREEDY (SPLIT POINTS) + SORTING, new imported
2561 Rearranging Fruits Python O(n log n) O(n) Hard greedy, GREEDY + COUNTING (with a “cheapest fruit as middleman” trick), new imported
2566 Maximum Difference by Remapping a Digit Python O(log(num)) O(log(num)) Easy greedy, GREEDY ON THE MOST SIGNIFICANT DIGIT, new imported
2567 Minimum Score by Changing Two Elements Python O(n * log(n)) O(n) for the sort Medium greedy, SORT + GREEDY (the low score is always free), new imported
2571 Minimum Operations to Reduce an Integer to 0 Python O(log(n)) O(1) Medium greedy, GREEDY ON THE LOWEST SET BIT (non-adjacent form / NAF), new imported
2573 Find the String with LCP Python O(n^2) O(n) Hard greedy, GREEDY CONSTRUCTION + FULL O(n^2) DP RE-VERIFICATION, new imported
2576 Find the Maximum Number of Marked Indices Python O(n * log n) O(1) beyond the sort Medium greedy, SORT + GREEDY TWO POINTERS, new imported
2578 Split With Minimum Sum Python O(d * log d) O(d) (d = number of digits, <= 10) Easy greedy, SORT DIGITS + GREEDY ALTERNATING DEAL, new imported
2587 Rearrange Array to Maximize Prefix Score Python O(n log n) O(n) for the sorted copy Medium greedy, GREEDY + SORT DESCENDING, new imported
2589 Minimum Time to Complete All Tasks Python O(n log n + n * m) O(m), with m = 2001 the time axis Hard greedy, GREEDY (SORT BY END TIME, THEN TURN ON THE LATEST SECONDS), new imported
2599 Make the Prefix Sum Non-negative Python O(n log n) O(n) Medium greedy, 🔒, GREEDY + MIN HEAP (undo the most damaging negative already taken), new imported
2600 K Items With the Maximum Sum Python O(1) O(1) Easy greedy, GREEDY (take the biggest labels first), new imported
2601 Prime Subtraction Operation Python O(V log log V + n * pi(V)) O(V) ; V = 1000 = max value Medium greedy, SIEVE + GREEDY (make every element as small as legally possible), new imported
2604 Minimum Time to Eat All Grains Python O((n + m) * log U + n log n + m log m) O(1) extra Hard greedy, 🔒, BINARY SEARCH ON THE ANSWER + GREEDY FEASIBILITY SWEEP, new imported
2606 Find the Substring With Maximum Cost Python O(n) O(26) Medium greedy, KADANE (MAXIMUM SUBARRAY SUM) ON THE MAPPED VALUES, new imported
2607 Make K-Subarray Sums Equal Python O(n log n) O(n) Medium greedy, GCD CYCLE GROUPING + MEDIAN, new imported
2611 Mice and Cheese Python O(n * log(n)) O(n) Medium greedy, GREEDY (start from “mouse 2 eats everything”, then buy back k swaps), new imported
2663 Lexicographically Smallest Beautiful String Python O(n * k) O(n) for the char list Hard greedy, GREEDY – “NEXT PERMUTATION” STYLE BUMP, THEN MINIMAL REFILL, new imported
2673 Make Costs of Paths Equal in a Binary Tree Python O(n) O(n) for the working copy Medium greedy, BOTTOM-UP GREEDY ON THE HEAP-INDEXED PERFECT TREE, new imported
2680 Maximum OR Python O(n) O(n) Medium greedy, GREEDY (spend all k doublings on ONE element) + PREFIX / SUFFIX OR, new imported
2697 Lexicographically Smallest Palindrome Python O(n) O(n) for the mutable char list Easy greedy, GREEDY + TWO POINTERS (each mirrored pair is independent), new imported
2708 Maximum Strength of a Group Python O(n log n) O(n) Medium greedy, GREEDY (take every positive, pair up the negatives), new imported
2712 Minimum Cost to Make All Characters Equal Python O(n) O(1) Medium greedy, GREEDY over the ADJACENT-PAIR BOUNDARIES, new imported
2734 Lexicographically Smallest String After Substring Operation Python O(n) O(n) Medium greedy, GREEDY - DECREMENT THE FIRST NON-‘a’ RUN, new imported
2769 Find the Maximum Achievable Number Python O(1) O(1) Easy greedy, GREEDY / MATH (each move closes a gap of 2), new imported
2772 Apply Operations to Make All Array Elements Equal to Zero Python O(n) O(n) Medium greedy, LEFT-TO-RIGHT GREEDY + DIFFERENCE ARRAY, new imported
2789 Largest Element in an Array after Merge Operations Python O(n) O(1) Medium greedy, GREEDY, SCAN FROM THE RIGHT, new imported
2790 Maximum Number of Groups With Increasing Length Python O(n log n) O(1) beyond the sort Hard greedy, SORT + GREEDY PREFIX BUDGET, new imported
2813 Maximum Elegance of a K-Length Subsequence Python O(n * log n) O(n) Hard greedy, GREEDY (SORT BY PROFIT DESC) + STACK OF “SACRIFICEABLE” DUPLICATES, new imported
2819 Minimum Relative Loss After Buying Chocolates Python O((n + q) * log n) O(n) Hard greedy, 🔒, SORT + PREFIX SUMS + GREEDY SHAPE (“CHEAP PREFIX + EXPENSIVE SUFFIX”), new imported
2825 Make String a Subsequence Using Cyclic Increments Python O(m + n) O(1) Medium greedy, GREEDY TWO POINTERS (relaxed subsequence match), new imported
2835 Minimum Operations to Form Subsequence With Target Sum Python O(n + 32 * 32) O(32) Hard greedy, GREEDY + BIT MANIPULATION (low bit -> high bit, split only on demand), new imported
2842 Count K-Subsequences of a String With Maximum Beauty Python O(n + 26 log 26) O(26) Hard greedy, GREEDY (pick the k biggest frequencies) + COMBINATORICS, new imported
2844 Minimum Operations to Make a Special Number Python O(4 * n) O(1) Medium greedy, GREEDY - only the LAST TWO digits decide divisibility by 25, new imported
2860 Happy Students Python O(n * log n) O(1) beyond the sort Medium greedy, SORT + ENUMERATE THE GROUP SIZE, new imported
2868 The Wording Game Python O(m + n) O(1) Hard greedy, 🔒, GREEDY SIMULATION + TWO POINTERS, new imported
2914 Minimum Number of Changes to Make Binary String Beautiful Python O(n) O(1) Medium greedy, GREEDY / PAIRING (fixed blocks of 2), new imported
3002 Maximum Size of a Set After Removals Python O(n) O(n) Medium greedy, GREEDY — SPEND EACH ARRAY’S HALF ON ITS EXCLUSIVE VALUES FIRST, new imported
3003 Maximize the Number of Partitions After Operations Python O(reachable states * 26) O(reachable states) Hard greedy, MEMOIZED DFS OVER (POSITION, CURRENT SEGMENT MASK, EDIT USED), new imported
3012 Minimize Length of Array Using Operations Python O(n) O(1) Medium greedy, EVERYTHING TURNS ON THE MINIMUM — CAN ANY VALUE BEAT IT MODULO ?, new imported
3014 Minimum Number of Pushes to Type Word I Python O(n) O(1) Easy greedy, FILL ALL 8 KEYS’ FIRST SLOTS BEFORE USING ANY SECOND SLOT, new imported
3016 Minimum Number of Pushes to Type Word II Python O(n) O(1) (26 counters) Medium greedy, EXCHANGE ARGUMENT — THE MOST FREQUENT LETTERS GET THE CHEAPEST SLOTS, new imported
3022 Minimize OR of Remaining Elements Using Operations Python O(30 * n) O(1) Hard greedy, DECIDE THE ANSWER BIT BY BIT, HIGH TO LOW, WITH A GREEDY FEASIBILITY TEST, new imported
3035 Maximum Palindromes After Operations Python O(total characters + n log n) O(n) Medium greedy, SWAPS ARE UNRESTRICTED — ONLY THE GLOBAL LETTER PAIRS MATTER, new imported
3068 Find the Maximum Sum of Node Values Python O(n) O(1) Hard greedy, THE TREE IS A RED HERRING — ANY EVEN-SIZED SUBSET CAN BE FLIPPED, new imported
3074 Apple Redistribution into Boxes Python O(m log m) O(m) Easy greedy, PACKS CAN BE SPLIT, SO ONLY THE TOTALS MATTER — TAKE THE BIGGEST BOXES, new imported
3075 Maximize Happiness of Selected Children Python O(n log n) O(n) Medium greedy, PICK THE HAPPIEST FIRST — THE i-TH PICK HAS ALREADY LOST i POINTS, new imported
3086 Minimum Moves to Pick K Ones Python O(n) O(n) Hard greedy, PRICE EVERY ONE, THEN NOTICE ONLY ~4 SPLITS BETWEEN REAL/CREATED MATTER, new imported
3088 Make String Anti-palindrome Python O(n log n) O(n) Hard greedy, 🔒, SORT, THEN REPAIR THE MIRROR CLASHES BY TOUCHING THE RIGHT HALF ONLY, new imported
3106 Lexicographically Smallest String After Operations With Constraint Python O(26 * n) O(n) Medium greedy, GREEDY LEFT TO RIGHT — SPEND THE BUDGET ON THE EARLIEST POSITIONS, new imported
3107 Minimum Operations to Make Median of Array Equal to K Python O(n log n) O(n) Medium greedy, SORT, THEN ONLY THE WRONG SIDE OF THE MEDIAN SLOT NEEDS FIXING, new imported
3111 Minimum Rectangles to Cover Points Python O(n log n) O(n) Medium greedy, y IS IRRELEVANT — IT IS A 1-D INTERVAL COVER ON THE x AXIS, new imported
3114 Latest Time You Can Obtain After Replacing Characters Python O(1) (720 candidates x 5 characters) O(1) Easy greedy, ONLY 720 VALID TIMES EXIST — TRY THEM FROM THE LATEST DOWN, new imported
3119 Maximum Number of Potholes That Can Be Fixed Python O(n log n) O(n) Medium greedy, 🔒, EACH REPAIR PAYS A FLAT +1 OVERHEAD — SO FIX THE LONGEST RUNS FIRST, new imported
3170 Lexicographically Minimum String After Removing Stars Python O(26 * n) worst case O(n) Medium greedy, ONE STACK OF POSITIONS PER LETTER — DELETE THE LATEST SMALLEST, new imported
3189 Minimum Moves to Get a Peaceful Board Python O(n log n) O(n) Medium greedy, 🔒, ROWS AND COLUMNS ARE INDEPENDENT — SORT EACH AND MATCH IN ORDER, new imported
3205 Maximum Array Hopping Score I Python O(n^2) O(n) Medium greedy, 🔒, PLAIN O(n^2) DP OVER THE LANDING INDEX, new imported
3207 Maximum Points After Enemy Battles Python O(n) O(1) Medium greedy, SPEND EVERYTHING ON THE CHEAPEST ENEMY, HARVEST ALL THE OTHERS ONCE, new imported
3216 Lexicographically Smallest String After a Swap Python O(n) O(n) Easy greedy, ONE SWAP, SO TAKE THE EARLIEST ONE THAT ACTUALLY HELPS, new imported
3218 Minimum Cost for Cutting Cake I Python O(m log m + n log n) O(m + n) Medium greedy, EXPENSIVE LINES FIRST — A LINE IS PAID ONCE PER PIECE IT CROSSES, new imported
3219 Minimum Cost for Cutting Cake II Python O(m log m + n log n) O(m + n) Hard greedy, IDENTICAL GREEDY TO LC 3218 — IT WAS ALREADY O(n log n), new imported
3221 Maximum Array Hopping Score II Python O(n) O(n) Medium greedy, 🔒, ALWAYS HOP TO THE LARGEST VALUE STILL AHEAD — THE SUFFIX MAXIMA, new imported
3228 Maximum Number of Operations to Move Ones to the End Python O(n) O(1) Medium greedy, EVERY 1 CAN CROSS EACH ZERO-BLOCK TO ITS RIGHT EXACTLY ONCE, new imported
3229 Minimum Operations to Make Array Equal to Target Python O(n) O(1) Hard greedy, WORK ON THE DIFFERENCE ARRAY — ONLY THE NEW DEMAND COSTS ANYTHING, new imported
3239 Minimum Number of Flips to Make Binary Grid Palindromic I Python O(m * n) O(1) Medium greedy, COUNT THE MISMATCHED MIRROR PAIRS, ONCE PER ORIENTATION, new imported
3240 Minimum Number of Flips to Make Binary Grid Palindromic II Python O(m * n) O(1) Medium greedy, GROUPS OF FOUR ARE FREE OF THE MOD-4 RULE — ONLY THE MIDDLES MATTER, new imported
3273 Minimum Amount of Damage Dealt to Bob Python O(n log n) O(n) Hard greedy, EXCHANGE ARGUMENT — ORDER THE KILLS BY damage / time, new imported
3282 Reach End of Array With Max Score Python O(n) O(1) Medium greedy, EVERY UNIT OF DISTANCE IS PAID AT THE BEST RATE SEEN SO FAR, new imported
3301 Maximize the Total Height of Unique Towers Python O(n log n) O(n) Medium greedy, SORT DESCENDING AND KEEP EACH TOWER AS TALL AS THE RULES ALLOW, new imported
3302 Find the Lexicographically Smallest Valid Sequence Python O(n + m) O(n) Medium greedy, PRECOMPUTE HOW MUCH OF word2 EACH SUFFIX CAN STILL MATCH, THEN BE GREEDY, new imported
3362 Zero Array Transformation III Python O((n + q) log q) O(n + q) Medium greedy, SWEEP LEFT TO RIGHT, ALWAYS SPENDING THE QUERY THAT REACHES FURTHEST, new imported
3397 Maximum Number of Distinct Elements After Operations Python O(n log n) O(1) beyond the sort Medium greedy, SORT, THEN GREEDILY PUSH EACH VALUE AS FAR LEFT AS ALLOWED, new imported
3402 Minimum Operations to Make Columns Strictly Increasing Python O(m * n) O(1) Easy greedy, PER-COLUMN GREEDY, RAISE EACH CELL TO THE MINIMUM LEGAL VALUE, new imported
3403 Find the Lexicographically Largest String From the Box I Python O(n^2) O(n) Medium greedy, EVERY SUBSTRING OF THE CAPPED LENGTH IS REACHABLE, new imported
3406 Find the Lexicographically Largest String From the Box II Python O(n) O(n) for the returned slice Hard greedy, 🔒, MAXIMUM SUFFIX (DUVAL-STYLE TWO POINTER), THEN TRUNCATE, new imported
3410 Maximize Subarray Sum After Removing All Occurrences of One Element Python O(n log n) O(n) Hard greedy, ZERO OUT ONE VALUE AT A TIME IN A MAX-SUBARRAY SEGMENT TREE, new imported
3424 Minimum Cost to Make Arrays Identical Python O(n log n) O(n) Medium greedy, ONLY TWO SCENARIOS EXIST — NEVER REARRANGE, OR REARRANGE ONCE, new imported
3443 Maximum Manhattan Distance After K Changes Python O(n) O(1) Medium greedy, AT EVERY PREFIX, EACH EDIT IS WORTH EXACTLY +2 — UNTIL THE PREFIX RUNS OUT, new imported
3506 Find Time Required to Eliminate Bacterial Strains Python O(n * log n) O(n) Hard greedy, 🔒, REVERSE THE SPLITS INTO MERGES, THEN GREEDY WITH A MIN-HEAP, new imported
3511 Make a Positive Array Python O(n) O(n) Medium greedy, 🔒, TURN IT INTO INTERVAL STABBING, THEN SWEEP WITH A MONOTONIC DEQUE, new imported
3517 Smallest Palindromic Rearrangement I Python O(n + 26 log 26) O(n) Medium greedy, A PALINDROME IS DETERMINED BY ITS FIRST HALF, new imported
3518 Smallest Palindromic Rearrangement II Python O(26 * n) O(n) Hard greedy, ONLY A SHORT SUFFIX OF THE HALF CAN VARY – FREEZE THE REST, THEN, new imported
3523 Make Array Non-decreasing Python O(n) O(1) Medium greedy, GREEDY — MERGE A DIP INTO THE BLOCK ON ITS LEFT, new imported
3542 Minimum Operations to Convert All Elements to Zero Python O(n) O(n) Medium greedy, MONOTONIC STACK OVER “NESTED” VALUE LEVELS, new imported
3545 Minimum Deletions for At Most K Distinct Characters Python O(n + 26 log 26) O(26) Easy greedy, DROP THE RAREST LETTERS FIRST, new imported
3557 Find Maximum Number of Non Intersecting Substrings Python O(n) O(1) Medium greedy, GREEDY — CLOSE EVERY CANDIDATE AT THE EARLIEST POSSIBLE END, new imported
3576 Transform Array to All Equal Elements Python O(n) O(1) Medium greedy, LEFT-TO-RIGHT FORCED SWEEP, ONE TARGET SIGN AT A TIME, new imported
3587 Minimum Adjacent Swaps to Alternate Parity Python O(n) O(n) Medium greedy, ADJACENT SWAPS = SUM OF |CURRENT INDEX - TARGET INDEX| PER PARITY CLASS, new imported
3627 Maximum Median Sum of Subsequences of Size 3 Python O(n log n) O(1) beyond the sort Medium greedy, SORT + PAIR EACH SMALL ELEMENT WITH THE TOP OF THE ARRAY, new imported
3630 Partition Array for Maximum XOR and AND Python O(2^n * n^2) O(2^n) Hard greedy, ENUMERATE B, THEN SOLVE THE A/C SPLIT IN CLOSED FORM WITH A XOR BASIS, new imported
3633 Earliest Finish Time for Land and Water Rides I Python O(n * m) O(1) Easy greedy, BRUTE FORCE OVER BOTH ORDERS, new imported
3635 Earliest Finish Time for Land and Water Rides II Python O(n log n + m log m) O(n + m) Medium greedy, SORT THE SECOND RIDE BY START TIME + PREFIX/SUFFIX MINIMA, new imported
3638 Maximum Balanced Shipments Python O(n) O(1) Medium greedy, GREEDY — CLOSE A SHIPMENT AT THE FIRST MOMENT IT BECOMES BALANCED, new imported
3645 Maximum Total from Optimal Activation Order Python O(n log n) O(n) Medium greedy, AT MOST L ELEMENTS OF limit == L CAN EVER BE ACTIVATED, new imported
3675 Minimum Operations to Transform String Python O(n) O(1) Medium greedy, THE ANSWER IS THE LONGEST DISTANCE TO ‘a’ AROUND THE CYCLE, new imported
3681 Maximum XOR of Subsequences Python O(n log C) O(log C) Hard greedy, TWO OVERLAPPING SUBSEQUENCES COLLAPSE TO ONE SUBSET – LINEAR BASIS, new imported

Hash Table

# Title Solution Time Space Difficulty Note Status
0159 Longest Substring with At Most Two Distinct Characters Python, Java O(n) O(1) Medium hash table, 🔒, sliding window with at most 2 distinct chars, LC 340, good basic, new, google, amazon, fb, microsoft imported
0982 Triples with Bitwise AND Equal To Zero Python, Java O(n^2 + n * 2^16) O(2^16) Hard hash table, precompute pairwise ANDs into a counter over 2^16 masks, new, google imported
1001 Grid Illumination Python O(m + q), m = len(lamps), q = len(queries) O(m) Hard hash table, HASH TABLE (count lamps per row / col / 2 diagonals), new imported
1133 Largest Unique Number Python O(n) O(n) Easy hash table, 🔒, HASH TABLE (counting), new, amazon imported
1153 String Transforms Into Another String Python O(n) O(1) Hard hash table, 🔒, HASH TABLE (functional mapping) + “spare character” argument, new, google, amazon imported
1160 Find Words That Can Be Formed by Characters Python O(L), L = total length of chars + all words O(1) Easy hash table, HASH TABLE (counting), new, amazon, fb imported
1165 Single-Row Keyboard Python O(n) O(1), 26 entries Easy hash table, 🔒, HASH TABLE (char -> index on keyboard), new, google imported
1198 Find Smallest Common Element in All Rows Python O(m * n) O(m * n), size of the counter Medium hash table, 🔒, HASH TABLE (counting), new, microsoft imported
1207 Unique Number of Occurrences Python O(n) O(n) Easy hash table, HASH TABLE (count) + SET (dedupe the counts), new, google, amazon, fb, apple imported
1224 Maximum Equal Frequency Python O(n) O(n) Hard hash table, HASH TABLE (count of values) + HASH TABLE (count of counts), new imported
1331 Rank Transform of an Array Python O(nlogn) O(n) Easy hash table, SORT + RANK DICT (rank = index in the sorted distinct values), new, google, amazon, fb imported
1418 Display Table of Food Orders in a Restaurant Python O(n + t * log t + m * log m + t * m) O(n) Medium hash table, HASH TABLE + SORTING (count (table, item) pairs, then lay out a grid), new imported
1452 People Whose List of Favorite Companies Is Not a Subset of Another List Python O(n^2 * m) O(n * m) Medium hash table, HASH TABLE (intern company name -> int id) + pairwise set subset check, new, google imported
1487 Making File Names Unique Python O(L) amortised O(L), L = total length of all names Medium hash table, HASH TABLE OF “NEXT SUFFIX TO TRY” (never restart k from 1), new, amazon, apple, microsoft imported
1577 Number of Ways Where Square of Number Is Equal to Product of Two Numbers Python O((n1 + n2) * D) O(D), D = #distinct values Medium hash table, HASH TABLE (count value pairs whose product equals x*x), new imported
1590 Make Sum Divisible by P Python O(n) O(n) Medium hash table, PREFIX SUM MOD + HASH TABLE (shortest subarray with a given remainder), new, amazon imported
1640 Check Array Formation Through Concatenation Python O(n) O(n) Easy hash table, HASH TABLE keyed on each piece’s HEAD value, new, fb, uber imported
1657 Determine if Two Strings Are Close Python O(n + m) O(1) (at most 26 letters) Medium hash table, HASH TABLE / COUNTING (two invariants under the allowed operations), new imported
1679 Max Number of K-Sum Pairs Python O(n) O(n) Medium hash table, HASH TABLE, ONE PASS (greedily close a pair the moment its partner exists), new, amazon imported
1711 Count Good Meals Python O(n * 22) O(n) Medium hash table, HASH TABLE + ENUMERATE THE 22 POSSIBLE POWERS OF TWO (“two sum” style), new, amazon imported
1748 Sum of Unique Elements Python O(n) O(n) Easy hash table, HASH TABLE COUNT, THEN SUM THE COUNT-ONE KEYS, new, fb imported
1781 Sum of Beauty of All Substrings Python O(n^2 * 26) O(26) Medium hash table, GROW EVERY SUBSTRING FROM A FIXED LEFT END, KEEPING A 26-SLOT COUNTER, new, google imported
1807 Evaluate the Bracket Pairs of a String Python O(n + m), n = len(s), m = len(knowledge) O(n + m) Medium hash table, HASH TABLE + ONE LINEAR SCAN (build the output in a list, join once), new, google imported
1814 Count Nice Pairs in an Array Python O(n * d), d = number of digits (<= 10) O(n) Medium hash table, REARRANGE THE EQUATION INTO AN INVARIANT, THEN GROUP-COUNT, new imported
1817 Finding the Users Active Minutes Python O(n + k) O(n) Medium hash table, HASH MAP OF SETS (id -> set of distinct minutes), then bucket the sizes, new imported
1925 Count Square Sum Triples Python O(n^2) O(n) Easy hash table, HASH SET OF SQUARES + ENUMERATE (a, b), new, amazon imported
1930 Unique Length-3 Palindromic Subsequences Python O(26 * n) O(26) Medium hash table, FIX THE OUTER CHARACTER (26 passes) + COUNT DISTINCT MIDDLES, new imported
1941 Check if All Characters Have Equal Number of Occurrences Python O(n) O(26) Easy hash table, HASH TABLE COUNT, THEN COLLAPSE THE COUNTS INTO A SET, new, microsoft imported
1995 Count Special Quadruplets Python O(n^2) O(n^2) worst case for the counter keys Easy hash table, HASH TABLE ON (nums[d] - nums[c]) -> O(n^2) instead of O(n^4), new imported
2006 Count Number of Pairs With Absolute Difference K Python O(n) O(n) Easy hash table, HASH TABLE (one pass, count partners already seen), new, amazon imported
2023 Number of Pairs of Strings With Concatenation Equal to Target Python O(n * L) O(n * L) Medium hash table, COUNT PREFIXES SEEN SO FAR, THEN THE MATCHING SUFFIXES, new, fb, apple imported
2025 Maximum Number of Ways to Partition an Array Python O(n) O(n) Hard hash table, PREFIX SUMS + TWO COUNTERS OF THE “DIFFERENCE” 2*prefix - total, new, google, fb imported
2032 Two Out of Three Python O(n1 + n2 + n3) O(number of distinct values) Easy hash table, DEDUPE EACH ARRAY FIRST, THEN COUNT HOW MANY ARRAYS HOLD EACH VALUE, new imported
2053 Kth Distinct String in an Array Python O(L) O(L), L = total length of all strings Easy hash table, HASH TABLE COUNTING (one pass to count, one pass to keep order), new, amazon imported
2068 Check Whether Two Strings are Almost Equivalent Python O(n + 26) O(26) Easy hash table, COUNT BOTH WORDS, COMPARE EVERY LETTER ‘a’…‘z’, new imported
2085 Count Common Words With One Occurrence Python O(n1 + n2) O(n1 + n2) Easy hash table, TWO COUNTERS, KEEP THE WORDS WITH COUNT == 1 IN BOTH, new imported
2120 Execution of All Suffix Instructions Staying in a Grid Python O(m^2) O(m) Medium hash table, DIRECT SIMULATION PER STARTING INDEX (m, n <= 500 so O(m^2) is fine), new imported
2150 Find All Lonely Numbers in the Array Python O(n) O(n) Medium hash table, ONE COUNTER ANSWERS BOTH HALVES OF THE CONDITION, new, google imported
2154 Keep Multiplying Found Values by Two Python O(n) O(n) Easy hash table, HASH SET + DOUBLING LOOP, new imported
2170 Minimum Operations to Make the Array Alternating Python O(n) O(n) Medium hash table, PICK ONE VALUE FOR THE EVEN SLOTS AND ANOTHER FOR THE ODD SLOTS, new imported
2190 Most Frequent Number Following Key In an Array Python O(n) O(n) Easy hash table, COUNT THE SUCCESSOR OF EVERY key OCCURRENCE, new imported
2201 Count Artifacts That Can Be Extracted Python O(len(dig) + len(artifacts)) O(len(dig)) Medium hash table, HASH THE EXCAVATED CELLS, THEN CHECK EACH ARTIFACT’S FOOTPRINT, new imported
2206 Divide Array Into Equal Pairs Python O(n) O(n) Easy hash table, EVERY VALUE MUST OCCUR AN EVEN NUMBER OF TIMES, new imported
2215 Find the Difference of Two Arrays Python O(n1 + n2) O(n1 + n2) Easy hash table, SET DIFFERENCE IN BOTH DIRECTIONS, new imported
2225 Find Players With Zero or One Losses Python O(n log n) O(n) Medium hash table, HASH TABLE (count losses; a player only “exists” if they played), new imported
2229 Check if an Array Is Consecutive Python O(n) O(n) Easy hash table, 🔒, HASH SET (three numbers must agree), new imported
2260 Minimum Consecutive Cards to Pick Up Python O(n) O(n) Medium hash table, HASH TABLE (closest previous index of the same value), new imported
2261 K Divisible Elements Subarrays Python O(n^3) worst case for the hashing of the tuples, O(n^2) windows O(n^2) Medium hash table, BRUTE FORCE ENUMERATION + HASH SET (n <= 200 so O(n^2) windows is fine), new imported
2283 Check if Number Has Equal Digit Count and Digit Value Python O(n) O(n) Easy hash table, COUNT THE DIGITS ONCE, THEN CHECK EVERY INDEX, new imported
2287 Rearrange Characters to Make Target String Python O(len(s) + len(target)) O(26) Easy hash table, THE BOTTLENECK LETTER DECIDES — TAKE THE MIN RATIO, new imported
2295 Replace Elements in an Array Python O(n + m) O(n) Medium hash table, TRACK WHERE EACH VALUE LIVES — POSITION MAP, NOT VALUE SCANNING, new imported
2306 Naming a Company Python O(26 * L + 26^2 * L) with L = total length O(L) Hard hash table, GROUP BY FIRST LETTER + COUNT SUFFIX OVERLAP (26 x 26 buckets), new imported
2309 Greatest English Letter in Upper and Lower Case Python O(n) O(1) Easy hash table, BITMASK OF SEEN LETTERS (26 bits for lower, 26 for upper), new imported
2325 Decode the Message Python O(len(key) + len(message)) O(26) Easy hash table, BUILD THE SUBSTITUTION TABLE FROM THE FIRST APPEARANCES IN key, new imported
2341 Maximum Number of Pairs in Array Python O(n) O(n) Easy hash table, EACH VALUE CONTRIBUTES count // 2 PAIRS AND count % 2 LEFTOVERS, new imported
2342 Max Sum of a Pair With Equal Sum of Digits Python O(n * d) O(number of distinct digit sums) Medium hash table, BUCKET BY DIGIT SUM, KEEP ONLY THE LARGEST SEEN PER BUCKET, new imported
2347 Best Poker Hand Python O(1) O(1) Easy hash table, TEST THE FOUR HANDS IN DESCENDING QUALITY AND RETURN THE FIRST HIT, new imported
2351 First Letter to Appear Twice Python O(n) O(26) Easy hash table, HASH SET (first char whose 2nd occurrence comes earliest = first repeat while scanning), new imported
2352 Equal Row and Column Pairs Python O(n^2) O(n^2) Medium hash table, HASH TABLE ON TUPLES (count rows, then look each column up), new imported
2354 Number of Excellent Pairs Python O(n + 31) O(n) Hard hash table, BIT COUNTING IDENTITY + SUFFIX COUNTS, new imported
2363 Merge Similar Items Python O((n + m) log(n + m)) O(n + m) Easy hash table, HASH TABLE (bucket weights by value, then sort the keys), new imported
2364 Count Number of Bad Pairs Python O(n) O(n) Medium hash table, COMPLEMENT COUNTING + HASH TABLE (rearrange the equation), new imported
2365 Task Scheduler II Python O(n) O(n) Medium hash table, GREEDY SIMULATION + HASH TABLE (earliest legal day per task type), new imported
2367 Number of Arithmetic Triplets Python O(n) O(n) Easy hash table, HASH SET (values are distinct + increasing, so a value fixes its index), new imported
2374 Node With Highest Edge Score Python O(n) O(n) Medium hash table, ACCUMULATE THE SOURCE LABELS INTO A SCORE ARRAY, THEN ARGMAX, new imported
2395 Find Subarrays With Equal Sum Python O(n) O(n) Easy hash table, HASH TABLE (remember every adjacent-pair sum we have already seen), new imported
2399 Check Distances Between Same Letters Python O(n) O(1) (26 slots) Easy hash table, HASH TABLE (record the first index of each letter, check on the 2nd), new imported
2404 Most Frequent Even Element Python O(n) O(n) Easy hash table, COUNT ONLY THE EVEN VALUES, THEN ARGMAX WITH A SMALLEST-VALUE TIE-BREAK, new imported
2423 Remove Letter To Equalize Frequency Python O(26 * 26) O(26) Easy hash table, TRY REMOVING ONE COPY OF EACH DISTINCT LETTER AND RE-CHECK, new imported
2441 Largest Positive Integer That Exists With Its Negative Python O(n) O(n) Easy hash table, HASH SET (membership test for the mirrored value), new imported
2442 Count Number of Distinct Integers After Reverse Operations Python O(n * d), d = number of digits (<= 7 here) O(n) Medium hash table, HASH SET (just collect every value and every reversed value), new imported
2451 Odd String Difference Python O(len(words) * n) O(len(words) * n) Easy hash table, GROUP THE WORDS BY THEIR DIFFERENCE SIGNATURE — THE ODD ONE IS ALONE, new imported
2452 Words Within Two Edits of Dictionary Python O(len(queries) * len(dictionary) * n) O(1) beyond the output Medium hash table, ALL WORDS SHARE A LENGTH, SO AN “EDIT” IS JUST A POSITION MISMATCH, new imported
2453 Destroy Sequential Targets Python O(n) O(n) Medium hash table, A SEED DESTROYS EXACTLY ITS OWN RESIDUE CLASS MOD space (from itself up), new imported
2456 Most Popular Video Creator Python O(n) O(n) Medium hash table, TWO PASSES OF BOOKKEEPING PER CREATOR, new imported
2484 Count Palindromic Subsequences Python O(100 * n) O(100) Hard hash table, FIX THE MIDDLE CHARACTER AND COUNT THE “ab” PAIRS ON EACH SIDE, new imported
2488 Count Subarrays With Median K Python O(n) O(n) Hard hash table, ONLY THE BALANCE OF “BIGGER THAN k” vs “SMALLER THAN k” MATTERS, new imported
2489 Number of Substrings With Fixed Ratio Python O(n) O(n) Medium hash table, 🔒, TURN THE RATIO INTO A SINGLE PREFIX QUANTITY THAT MUST REPEAT, new imported
2491 Divide Players Into Teams of Equal Skill Python O(n log n) O(n) Medium hash table, SORT AND PAIR THE ENDS — THE TARGET SUM IS FORCED, new imported
2501 Longest Square Streak in an Array Python O(n * log log M) O(n) Medium hash table, HASH SET + FOLLOW THE SQUARING CHAIN, new imported
2531 Make Number of Distinct Characters Equal Python O(m + n + 26^2) O(26) Medium hash table, COUNTING + ENUMERATE THE 26 x 26 CHARACTER PAIRS, new imported
2564 Substring XOR Queries Python O(n * 32 + m) O(n * 32) Medium hash table, HASH TABLE PRE-COMPUTATION OVER SHORT WINDOWS + XOR IDENTITY, new imported
2588 Count the Number of Beautiful Subarrays Python O(n) O(n) Medium hash table, PREFIX XOR + HASH MAP (same trick as “subarray sum equals K”), new imported
2598 Smallest Missing Non-negative Integer After Operations Python O(n) O(min(n, value)) Medium hash table, COUNT REMAINDERS mod value, THEN GREEDILY FILL 0, 1, 2, …, new imported
2605 Form Smallest Number From Two Digit Arrays Python O(m + n) O(m + n) Easy hash table, HASH SET INTERSECTION + 2-DIGIT FALLBACK, new imported
2661 First Completely Painted Row or Column Python O(m * n) O(m * n) Medium hash table, HASH TABLE (value -> cell) + PER ROW / PER COLUMN PAINT COUNTERS, new imported
2670 Find the Distinct Difference Array Python O(n) O(n) Easy hash table, PRECOMPUTE SUFFIX DISTINCT COUNTS, THEN SWEEP THE PREFIX, new imported
2716 Minimize String Length Python O(n) O(|charset|) = O(26) Easy hash table, HASH SET (count of DISTINCT characters), new imported
2718 Sum of Matrix After Queries Python O(m) O(n) (m = len(queries)) Medium hash table, HASH SET + REVERSE SCAN, new imported
2744 Find Maximum Number of String Pairs Python O(n * L) O(n * L) Easy hash table, HASH SET OF ALREADY-SEEN WORDS (ONE PASS), new imported
2748 Number of Beautiful Pairs Python O(n * 10 * log(10)) O(10) = O(1) Easy hash table, HASH TABLE (bucket counting on the 9 possible leading digits), new imported
2784 Check if Array is Good Python O(n) O(n) Easy hash table, COUNTING, new imported
2808 Minimum Seconds to Equalize a Circular Array Python O(n) O(n) Medium hash table, GROUP INDICES BY VALUE + LARGEST CIRCULAR GAP, new imported
2815 Max Pair Sum in an Array Python O(n * log10(max(nums))) O(1) # 10 buckets only Easy hash table, BUCKET BY LARGEST DIGIT + KEEP THE RUNNING BEST PER BUCKET, new imported
2839 Check if Strings Can be Made Equal With Operations I Python O(1) (length is fixed at 4) O(1) Easy hash table, PARITY CLASSES + COUNTING, new imported
2840 Check if Strings Can be Made Equal With Operations II Python O(n + 26) O(26) Medium hash table, PARITY CLASSES + COUNTING (hash table over 2 x 26 counters), new imported
2845 Count of Interesting Subarrays Python O(n) O(n) Medium hash table, PREFIX SUM (mod) + HASH TABLE – the “subarray sum equals target” trick, new imported
3005 Count Elements With Maximum Frequency Python O(n) O(n) Easy hash table, COUNT, TAKE THE MAX, THEN SUM THE COUNTS THAT MATCH IT, new imported
3039 Apply Operations to Make String Empty Python O(n) O(1) (26 counters) Medium hash table, THE SURVIVORS ARE THE MOST FREQUENT LETTERS, IN LAST-OCCURRENCE ORDER, new imported
3044 Most Frequent Prime Python O(m * n * max(m,n) * sqrt(max value)) O(number of primes seen) Medium hash table, THE GRID IS TINY — ENUMERATE EVERY RAY AND TEST PRIMALITY, new imported
3046 Split the Array Python O(n) O(n) Easy hash table, A VALUE CAN APPEAR AT MOST ONCE PER HALF, SO AT MOST TWICE OVERALL, new imported
3078 Match Alphanumerical Pattern in Matrix I Python O(m * n * pm * pn) O(1) (at most 10 letters can map) Medium hash table, 🔒, TRY EVERY ANCHOR, VERIFY WITH A BIJECTIVE LETTER -> DIGIT MAP, new imported
3083 Existence of a Substring in a String and Its Reverse Python O(n) O(n) Easy hash table, A LENGTH-2 SUBSTRING IS IN reverse(s) IFF ITS REVERSE IS IN s, new imported
3137 Minimum Number of Operations to Make Word K-Periodic Python O(n) O(n) Medium hash table, THE BLOCKS ARE INTERCHANGEABLE — KEEP THE MOST COMMON ONE, new imported
3138 Minimum Length of Anagram Concatenation Python O(d(g) * n log n) worst case O(n) Medium hash table, THE BLOCK COUNT MUST DIVIDE EVERY LETTER’S TOTAL — THEN VERIFY, new imported
3143 Maximum Points Inside the Square Python O(n) O(1) (26 tags) Medium hash table, A SQUARE IS JUST A CHEBYSHEV RADIUS — FIND WHERE THE FIRST TAG REPEATS, new imported
3146 Permutation Difference between Two Strings Python O(n) O(n) Easy hash table, INDEX EACH CHARACTER ONCE, THEN SUM THE SHIFTS, new imported
3158 Find the XOR of Numbers Which Appear Twice Python O(n) O(n) Easy hash table, A SET REMEMBERS WHAT HAS BEEN SEEN — XOR ON THE SECOND SIGHTING, new imported
3160 Find the Number of Distinct Colors Among the Balls Python O(n) O(n) Medium hash table, TWO MAPS — BALL -> ITS COLOR, AND COLOR -> HOW MANY BALLS WEAR IT, new imported
3167 Better Compression of String Python O(n) O(1) (26 counters) Medium hash table, 🔒, PARSE LETTER-THEN-NUMBER, ACCUMULATE, THEN EMIT IN ALPHABETICAL ORDER, new imported
3184 Count Pairs That Form a Complete Day I Python O(n^2) O(1) Easy hash table, n <= 100 — TEST EVERY PAIR, new imported
3185 Count Pairs That Form a Complete Day II Python O(n) O(1) (24 counters) Medium hash table, ONLY THE RESIDUE MOD 24 MATTERS — COUNT THE COMPLEMENT ON THE FLY, new imported
3223 Minimum Length of String After Operations Python O(n) O(1) (26 counters) Medium hash table, EACH OPERATION REMOVES TWO COPIES OF ONE LETTER — SO ONLY PARITY MATTERS, new imported
3238 Find the Number of Winning Players Python O(len(pick) + n * colors) O(n * colors) Easy hash table, TALLY (PLAYER, COLOR) PAIRS, THEN COMPARE EACH PLAYER’S BEST COLOR, new imported
3295 Report Spam Message Python O(n + m) O(m) Medium hash table, HASH THE BANNED LIST, THEN COUNT HITS AND STOP AT TWO, new imported
3365 Rearrange K Substrings to Form Target String Python O(n) O(n) Medium hash table, THE BLOCKS ARE ATOMIC — SO COMPARE THE TWO MULTISETS OF BLOCKS, new imported
3371 Identify the Largest Outlier in an Array Python O(n) O(n) Medium hash table, PICK THE SUM ELEMENT, AND THE OUTLIER FALLS OUT OF THE TOTAL, new imported
3396 Minimum Number of Operations to Make Elements in Array Distinct Python O(n) O(n) Easy hash table, FIND THE LONGEST DISTINCT SUFFIX, THEN CEIL-DIVIDE BY 3, new imported
3404 Count Special Subsequences Python O(n^2 log(max)) O(n^2) worst case for the fraction counter Medium hash table, REWRITE THE PRODUCT EQUATION AS A RATIO, THEN COUNT PAIRS BY RATIO, new imported
3438 Find Valid Pair of Adjacent Digits in String Python O(n) O(1) Easy hash table, COUNT ONCE UP FRONT, THEN THE SCAN IS A LOCAL TEST, new imported
3442 Maximum Difference Between Even and Odd Frequency I Python O(n) O(1) Easy hash table, THE TWO SIDES OF THE DIFFERENCE ARE INDEPENDENT, new imported
3527 Find the Most Common Response Python O(total tokens) O(distinct tokens) Medium hash table, DEDUPLICATE PER DAY, THEN ARGMAX WITH A LEXICOGRAPHIC TIE-BREAK, new imported
3541 Find Most Frequent Vowel and Consonant Python O(n) O(1) Easy hash table, TWO INDEPENDENT MAXIMA OVER A SINGLE FREQUENCY TABLE, new imported
3572 Maximize Y‑Sum by Picking a Triplet of Distinct X‑Values Python O(n) O(n) Medium hash table, KEEP ONLY THE BEST Y PER DISTINCT X, THEN TAKE THE TOP THREE, new imported
3581 Count Odd Letters from Number Python O(log n) O(1) Easy hash table, 🔒, XOR PARITY MASK OVER THE 26 LETTERS, new imported
3591 Check if Any Element Has Prime Frequency Python O(n * sqrt(n)) O(n) Easy hash table, COUNT, THEN TRIAL-DIVIDE THE COUNTS, new imported
3636 Threshold Majority Queries Python O(n^2 / B + q * B log n) O(n^2 / B^2 + n) Hard hash table, RANGE MODE BY BLOCK PRECOMPUTATION + A CANDIDATE SCAN OF THE EDGES, new imported
3662 Filter Characters by Frequency Python O(n) O(1) – the counter holds at most 26 keys Easy hash table, 🔒, COUNT THEN FILTER (TWO PASSES), new imported
3663 Find The Least Frequent Digit Python O(log n) O(1) Easy hash table, COUNT DIGITS, THEN PICK BY (FREQUENCY, DIGIT) — SKIPPING ABSENT ONES, new imported
3668 Restore Finishing Order Python O(n) O(n) Easy hash table, ONE PASS OVER order, FILTERING BY A MEMBERSHIP SET, new imported
3678 Smallest Absent Positive Greater Than Average Python O(n) O(n) Easy hash table, FLOOR OF THE AVERAGE + 1, THEN WALK PAST PRESENT VALUES, new imported
3682 Minimum Index Sum of Common Elements Python O(n) O(n) Medium hash table, 🔒, PER-VALUE EARLIEST INDEX, THEN ONE PASS, new imported

Linked list

# Title Solution Time Space Difficulty Note Status
1171 Remove Zero Sum Consecutive Nodes from Linked List Python O(n) O(n) Medium linked list, PREFIX SUM + HASH TABLE (2 passes), new, amazon, apple, uber imported
1180 Count Substrings with Only One Distinct Letter Python O(n) O(1) Easy linked list, 🔒, TWO POINTERS (group equal-letter runs), new, amazon imported
1181 Before and After Puzzle Python O(n^2 * L) worst case O(n * L) Medium linked list, 🔒, HASH TABLE (index the first word) + SET dedup, new imported
1265 Print Immutable Linked List in Reverse Python O(n) O(n), recursion stack Medium linked list, 🔒, RECURSION, new, google, fb imported
1290 Convert Binary Number in a Linked List to Integer Python O(n) O(1) Easy linked list, LINKED LIST traversal + BIT SHIFT, new, google, amazon, uber imported
1474 Delete N Nodes After M Nodes of a Linked List Python O(N) O(1) Easy linked list, 🔒, SIMULATION (in-place pointer surgery), new imported
1634 Add Two Polynomials Represented as Linked Lists Python O(m + n) O(1) extra (besides the output list) Medium linked list, 🔒, MERGE TWO SORTED LISTS (both are strictly descending by power), new, amazon imported
1669 Merge In Between Linked Lists Python O(n + m) O(1) Medium linked list, POINTER SURGERY (find the two splice points, then relink), new, amazon imported
1721 Swapping Nodes in a Linked List Python O(n) O(1) Medium linked list, TWO POINTERS, FIXED GAP (one pass, no length precomputation), new, amazon, fb, microsoft imported
2058 Find the Minimum and Maximum Number of Nodes Between Critical Points Python O(n) O(1) Medium linked list, SINGLE PASS, KEEP FIRST / PREVIOUS CRITICAL INDEX, new imported
2095 Delete the Middle Node of a Linked List Python O(n) O(1) Medium linked list, SLOW / FAST POINTERS, WITH slow LAGGING ONE NODE BEHIND, new imported
2130 Maximum Twin Sum of a Linked List Python O(n) O(1) Medium linked list, SLOW/FAST TO THE MIDDLE, REVERSE THE SECOND HALF, WALK IN LOCKSTEP, new, amazon imported
2181 Merge Nodes in Between Zeros Python O(n) O(1) extra (output nodes aside) Medium linked list, ONE PASS ON THE LINKED LIST (accumulate until the next 0), new imported
2487 Remove Nodes From Linked List Python O(n) O(1) Medium linked list, REVERSE, KEEP A RUNNING MAXIMUM, REVERSE BACK, new imported
2674 Split a Circular Linked List Python O(n) O(1) Medium linked list, 🔒, FAST / SLOW POINTERS ON A CIRCULAR LIST, new imported
2816 Double a Number Represented as a Linked List Python O(n) O(1) Medium linked list, SINGLE FORWARD PASS - LOOK-AHEAD CARRY (NO REVERSING NEEDED), new imported
3062 Winner of the Linked List Game Python O(n) O(1) Easy linked list, 🔒, WALK TWO NODES AT A TIME AND KEEP A RUNNING SCORE DIFFERENCE, new imported
3063 Linked List Frequency Python O(n) O(k) Easy linked list, 🔒, COUNT INTO A HASH MAP, THEN REBUILD A LIST FROM THE COUNTS, new imported
3217 Delete Nodes From Linked List Present in Array Python O(n + m) O(m) Medium linked list, HASH THE VALUES, THEN ONE UNLINKING PASS BEHIND A DUMMY HEAD, new imported
3263 Convert Doubly Linked List to Array I Python O(n) O(n) for the output Easy linked list, 🔒, WALK FORWARD FROM THE HEAD — THE prev POINTERS ARE NOT NEEDED, new imported
3294 Convert Doubly Linked List to Array II Python O(n) O(n) for the output Medium linked list, 🔒, WALK BACK TO THE HEAD FIRST — THAT IS WHAT prev IS FOR, new imported

Math

# Title Solution Time Space Difficulty Note Status
0065 Valid Number Python, Java O(n) O(n) Hard math, finite state machine, or careful manual parsing, complex, new, string, google, amazon, fb, microsoft, linkedin imported
0233 Number of Digit One Python, Java O(logn) O(1) Hard math, count the 1s per digit position, digit dp, good trick, new, google, amazon, apple, microsoft, uber imported
0248 Strobogrammatic Number III Python, Java O(5^(l/2) * l) O(5^(l/2) * l) Hard math, 🔒, LC 246, LC 247, build strobogrammatic numbers per length and compare bounds, new, array, string, recursion, google, fb imported
0391 Perfect Rectangle Python, Java O(n) O(n) Hard math, corner-count parity + total area check, hashset, good trick, new, google, apple imported
0479 Largest Palindrome Product Python, Java O(10^(2n)) O(1) Hard math, build palindromes downward and test their factors, new imported
0483 Smallest Good Base Python, Java O((logn)^3) O(1) Hard math, enumerate the digit count then binary search the base, new, google, microsoft imported
0492 Construct the Rectangle Python, Java O(sqrt(area)) O(1) Easy math, walk down from sqrt(area) to the first divisor, basic, new imported
0660 Remove 9 Python, Java O(logn) O(logn) Hard math, 🔒, treat n as a base-9 number, good trick, new, google imported
0780 Reaching Points Python, Java O(log(max(x, y))) O(1) Hard math, work backwards with modulo instead of subtraction, good trick, new, google, amazon, uber imported
0782 Transform to Chessboard Python, Java O(n^2) O(1) Hard math, check the row patterns then count the minimum swaps, bit manipulation, new, google imported
0810 Chalkboard XOR Game Python, Java O(n) O(1) Hard math, game theory: the first player wins if xor != 0 or n is even, new imported
0887 Super Egg Drop Python, Java O(k * n) O(k) Hard math, dp on (eggs, moves) -> max floors, binary search, good trick, new, google, amazon, fb imported
0899 Orderly Queue Python, Java O(n^2) O(n) Hard math, k == 1 means try every rotation, otherwise just sort, trick, new, amazon imported
0902 Numbers At Most N Given Digit Set Python, Java O(m * d) O(1) Hard math, digit dp counting numbers <= n built from a digit set, new, amazon imported
0906 Super Palindromes Python, Java O(M^(1/4) * logM) O(1) Hard math, enumerate palindrome roots and test their squares, new, google imported
0972 Equal Rational Numbers Python, Java O(l) O(1) Hard math, parse the repeating decimal into an exact fraction, new, microsoft imported
1006 Clumsy Factorial Python O(n) O(1) Medium math, SIMULATION, group the terms 4 at a time, new, microsoft imported
1009 Complement of Base 10 Integer Python O(log n) O(1) Easy math, BIT MANIPULATION, build an all-1 mask of the SAME bit length as n, new imported
1012 Numbers With Repeated Digits Python O(L^2), L = number of digits ~ 10 O(L) Hard math, COMBINATORICS (count the COMPLEMENT), new, google imported
1017 Convert to Base -2 Python O(log n) O(log n) Medium math, REPEATED DIVISION BY -2, new imported
1037 Valid Boomerang Python O(1) O(1) Easy math, CROSS PRODUCT (avoid slope division / zero-division), new, google imported
1067 Digit Count in Range Python O(len(n) * len(n) * 10) O(len(n) * len(n)) Hard math, 🔒, DIGIT DP + prefix trick count(high) - count(low - 1), new, amazon imported
1073 Adding Two Negabinary Numbers Python O(n), n = max(len(arr1), len(arr2)) O(n) Medium math, SCHOOL BOOK ADDITION with a base -2 carry, new imported
1079 Letter Tile Possibilities Python O(n!) worst case (n <= 7) O(n) Medium math, BACKTRACK on a letter COUNTER (dedupe by letter, not by position), new, google imported
1088 Confusing Number II Python O(5^len(n)) O(len(n)) Hard math, 🔒, DIGIT DFS (only generate numbers made of 0,1,6,8,9) + check rotation, new, google imported
1103 Distribute Candies to People Python O(sqrt(candies)) O(num_people) Easy math, SIMULATION, new imported
1118 Number of Days in a Month Python O(1) O(1) Easy math, 🔒, MATH (leap year rule + month length lookup table), new, amazon imported
1128 Number of Equivalent Domino Pairs Python O(n) O(1) Easy math, HASH TABLE (counting) + normalize each domino to a 2 digit key, new, amazon imported
1134 Armstrong Number Python O(log n) O(1) Easy math, 🔒, MATH (simulation), new, amazon imported
1154 Day of the Year Python O(1) O(1) Easy math, MATH (sum days of all previous months + day), new imported
1175 Prime Arrangements Python O(n log log n) O(n) Easy math, MATH (SIEVE + FACTORIAL), new, amazon imported
1185 Day of the Week Python O(year) O(1) Easy math, ZELLER-STYLE DAY COUNTING (days elapsed since a known anchor), new, apple, microsoft imported
1217 Minimum Cost to Move Chips to The Same Position Python O(n) O(1) Easy math, MATH / PARITY (greedy), new, amazon, apple imported
1227 Airplane Seat Assignment Probability Python O(1) O(1) Medium math, MATH / BRAINTEASER, new, google imported
1232 Check If It Is a Straight Line Python O(n) O(1) Easy math, MATH / CROSS PRODUCT, new imported
1237 Find Positive Integer Solution for a Given Equation Python O(n) O(1) Medium math, TWO POINTERS (start at top-left corner of the “sorted matrix”), new, google imported
1238 Circular Permutation in Binary Representation Python O(2^n) O(1) Medium math, GRAY CODE + XOR SHIFT, new imported
1250 Check If It Is a Good Array Python O(n log m), m = max(nums) O(1) Hard math, MATH - BEZOUT’S IDENTITY, new imported
1256 Encode Number Python O(log num) O(log num) Medium math, MATH / BIT TRICK (the table is just binary of num + 1 with the leading 1 dropped), new imported
1259 Handshakes That Don’t Cross Python O(n^2) O(n) Hard math, DP (Catalan number recurrence), new, amazon imported
1266 Minimum Time Visiting All Points Python O(n) O(1) Easy math, MATH (Chebyshev distance), new, google, amazon, fb, apple imported
1276 Number of Burgers with No Waste of Ingredients Python O(1) O(1) Medium math, MATH (solve the 2 x 2 linear system), new imported
1281 Subtract the Product and Sum of Digits of an Integer Python O(log n) O(1) Easy math, DIGIT EXTRACTION, new, uber imported
1300 Sum of Mutated Array Closest to Target Python O(n log n) O(n) Medium math, BINARY SEARCH on the answer (the mutated sum is monotonic in value), new, google, apple imported
1317 Convert Integer to the Sum of Two No-Zero Integers Python O(n log n) O(log n) Easy math, brute force enumeration of a, then b = n - a, new imported
1323 Maximum 69 Number Python O(d) O(d) d = number of digits Easy math, GREEDY (flip the LEFTMOST 6 into a 9), new imported
1330 Reverse Subarray To Maximize Array Value Python O(n) O(1) Hard math, MATH (a reversal only rewires 2 boundaries -> maximise the delta), new imported
1344 Angle Between Hands of a Clock Python O(1) O(1) Medium math, MATH, new, google, amazon, fb, apple, microsoft, uber imported
1359 Count All Valid Pickup and Delivery Options Python O(n) O(1) Hard math, COMBINATORICS / 1D DP, new, microsoft imported
1360 Number of Days Between Two Dates Python O(y + m) O(1) Easy math, MATH - convert each date to a “days since 1971-01-01” ordinal, new, amazon, fb, microsoft imported
1362 Closest Divisors Python O(sqrt(num)) O(1) Medium math, ENUMERATE DIVISORS DOWN FROM sqrt(x), new, amazon imported
1363 Largest Multiple of Three Python O(n log n) O(n) Hard math, DP (max count per remainder) + BACKTRACK THE CHOICES, new, google, amazon imported
1390 Four Divisors Python O(n * sqrt(m)) O(1) m = max(nums) Medium math, TRIAL DIVISION up to sqrt(x), stop as soon as the 4th divisor appears, new imported
1401 Circle and Rectangle Overlapping Python O(1) O(1) Medium math, MATH (clamp the centre into the rectangle, then measure), new, google imported
1415 The k-th Lexicographical String of All Happy Strings of Length n Python O(n) O(n) Medium math, COUNTING / DIGIT SELECTION (no need to enumerate every string), new imported
1442 Count Triplets That Can Form Two Arrays of Equal XOR Python O(n^2) O(1) Medium math, XOR PREFIX TRICK, new imported
1447 Simplified Fractions Python O(n^2 * log n) O(1) besides the output Medium math, ENUMERATE PAIRS + GCD (a fraction is simplified iff gcd == 1), new, google imported
1486 XOR Operation in an Array Python O(n) O(1) Easy math, DIRECT SIMULATION (n <= 1000, just fold the XOR), new, apple imported
1497 Check If Array Pairs Are Divisible by k Python O(n + k) O(k) Medium math, COUNT REMAINDERS, new, amazon, uber imported
1512 Number of Good Pairs Python O(n) O©, C = number of distinct values Easy math, RUNNING COUNTER, new, google, amazon, apple, microsoft imported
1513 Number of Substrings With Only 1s Python O(n) O(1) Medium math, COUNT RUNS INCREMENTALLY, new, google imported
1525 Number of Good Ways to Split a String Python O(n) O(26) Medium math, SWEEP THE CUT, MAINTAIN DISTINCT COUNTS ON BOTH SIDES, new, google, apple imported
1537 Get the Maximum Score Python O(m + n) O(1) Hard math, MERGE THE TWO SORTED ARRAYS, SETTLE THE CHOICE AT EACH CROSSING, new, amazon, microsoft imported
1551 Minimum Operations to Make Array Equal Python O(1) O(1) Medium math, MATH (pair up the smallest with the largest), new, microsoft imported
1611 Minimum One Bit Operations to Make Integers Zero Python O(log n) O(1) Hard math, GRAY CODE (n is a Gray code; the answer is its rank), new imported
1641 Count Sorted Vowel Strings Python O(1) O(1) Medium math, STARS AND BARS (a sorted string is just a multiset of 5 vowels), new, google, amazon imported
1643 Kth Smallest Instructions Python O((row + col)^2) O(row + col) Hard math, COMBINATORIAL COUNTING, build the answer greedily left to right, new imported
1735 Count Ways to Make Array With Product Python O(K log log K + q * log K) O(K), K = 10^4 Hard math, PRIME FACTORISATION + STARS AND BARS, new, amazon imported
1739 Building Boxes Python O(sqrt(n)) O(1) Hard math, GREEDY STAIRCASE + MATH (build a corner pyramid, then extend it), new imported
1744 Can You Eat Your Favorite Candy on Your Favorite Day? Python O(n + q) O(n) Medium math, PREFIX SUM + INTERVAL OVERLAP (two ranges must intersect), new imported
1753 Maximum Score From Removing Stones Python O(1) O(1) Medium math, MATH / GREEDY (always draw from the two currently largest piles), new, google imported
1776 Car Fleet II Python O(n) amortised O(n) Hard math, MONOTONIC STACK SCANNED RIGHT TO LEFT, new, google imported
1780 Check if Number is a Sum of Powers of Three Python O(log n) O(1) Medium math, BASE-3 REPRESENTATION (distinct powers of 3 <=> every trit is 0 or 1), new, microsoft imported
1808 Maximize Number of Nice Divisors Python O(log primeFactors) O(1) Hard math, INTEGER BREAK (maximize a product of parts summing to primeFactors), new imported
1812 Determine Color of a Chessboard Square Python O(1) O(1) Easy math, PARITY (a chessboard colours by (file + rank) % 2), new imported
1819 Number of Different Subsequences GCDs Python O(M log M + n), M = max(nums) O(M) Hard math, ENUMERATE THE CANDIDATE GCD, NOT THE SUBSEQUENCE (harmonic sieve), new imported
1822 Sign of the Product of an Array Python O(n) O(1) Easy math, TRACK THE SIGN ONLY (never build the product), new, microsoft imported
1823 Find the Winner of the Circular Game Python O(n) O(1) Medium math, JOSEPHUS RECURRENCE, BOTTOM-UP (linear time, constant space), new, apple imported
1828 Queries on Number of Points Inside a Circle Python O(n * q) O(1) extra Medium math, BRUTE FORCE WITH SQUARED DISTANCES (500 x 500 is tiny), new, google imported
1830 Minimum Number of Operations to Make String Sorted Python O(n * 26) O(n) Hard math, THE OPERATION IS “PREVIOUS PERMUTATION” -> ANSWER = RANK OF s, new imported
1835 Find XOR Sum of All Pairs Bitwise AND Python O(n + m) O(1) Hard math, AND DISTRIBUTES OVER XOR -> (XOR arr1) AND (XOR arr2), new imported
1837 Sum of Digits in Base K Python O(log_k n) O(1) Easy math, REPEATED DIVMOD (peel off base-k digits from the least significant end), new imported
1860 Incremental Memory Leak Python O(sqrt(memory1 + memory2)) O(1) Medium math, DIRECT SIMULATION (it terminates in O(sqrt(total)) steps), new imported
1862 Sum of Floored Pairs Python O(n + M log M), M = max(nums) <= 10^5 O(M) Hard math, COUNTING + PREFIX SUM OVER MULTIPLES (harmonic series), new imported
1863 Sum of All Subset XOR Totals Python O(n) O(1) Easy math, BIT CONTRIBUTION (answer = OR(nums) * 2^(n-1)), new, amazon, neetcode250 imported
1884 Egg Drop With 2 Eggs and N Floors Python O(sqrt(n)) O(1) Medium math, MATH (with a budget of k drops, 2 eggs can cover k*(k+1)/2 floors), new, google, fb, microsoft imported
1904 The Number of Full Rounds You Have Played Python O(1) O(1) Medium math, CONVERT TO MINUTES, THEN COUNT WHOLE 15-MINUTE SLOTS, new imported
1916 Count Ways to Build Rooms in an Ant Colony Python O(n log MOD) O(n) Hard math, HOOK LENGTH FORMULA FOR TREES (count linear extensions of a rooted tree), new imported
1922 Count Good Numbers Python O(log n) O(1) Medium math, COMBINATORICS + FAST POWER (each position is independent), new, google, amazon imported
1945 Sum of Digits of String After Convert Python O(n + k) O(n) Easy math, STRAIGHT SIMULATION (the number shrinks to <= 2 digits almost at once), new imported
1952 Three Divisors Python O(sqrt(n)) O(1) Easy math, NUMBER THEORY (exactly 3 divisors <=> n is the SQUARE OF A PRIME), new imported
1954 Minimum Garden Perimeter to Collect Enough Apples Python O(log X) O(1) Medium math, CLOSED-FORM APPLE COUNT + BINARY SEARCH ON THE HALF-SIDE, new, amazon imported
1969 Minimum Non-Zero Product of the Array Elements Python O(p) (fast power over a p-bit exponent) O(1) Medium math, GREEDY / MATH (pair x with 2^p-1-x, then FAST POWER), new imported
1980 Find Unique Binary String Python O(n) O(n) for the answer Medium math, CANTOR DIAGONAL (flip the i-th bit of the i-th string), new, amazon imported
1982 Find Array Given Subset Sums Python O(2^n * n) O(2^n) Hard math, DIVIDE AND CONQUER ON THE SORTED MULTISET (peel one element at a time), new imported
2005 Subtree Removal Game with Fibonacci Tree Python O(n) O(n) Hard math, 🔒, SPRAGUE-GRUNDY / COLON PRINCIPLE ON A ROOTED TREE, new imported
2063 Vowels of All Substrings Python O(n) O(1) Medium math, COUNT EACH VOWEL’S CONTRIBUTION (combinatorics, no substring loop), new imported
2073 Time Needed to Buy Tickets Python O(n) O(1) Easy math, COUNT EACH PERSON’S CONTRIBUTION DIRECTLY (no simulation needed), new imported
2083 Substrings That Begin and End With the Same Letter Python O(n) O(26) Medium math, 🔒, COMBINATORICS PER LETTER — CHOOSE 2 POSITIONS (plus the singletons), new, google imported
2091 Removing Minimum and Maximum From Array Python O(n) O(1) Medium math, ONLY THREE STRATEGIES EXIST — TRY ALL THREE, new imported
2110 Number of Smooth Descent Periods of a Stock Python O(n) O(1) Medium math, COUNT THE RUN LENGTH ENDING AT EACH DAY, new, amazon imported
2117 Abbreviating the Product of a Range Python O(right - left) big-int multiplications O(1) Hard math, HANDLE THE THREE PIECES SEPARATELY — ZEROS, SUFFIX, PREFIX, new imported
2119 A Number After a Double Reversal Python O(1) O(1) Easy math, THE DOUBLE REVERSAL ONLY LOSES TRAILING ZEROS, new imported
2133 Check if Every Row and Column Contains All Numbers Python O(n^2) O(n) Easy math, EVERY ROW AND EVERY COLUMN MUST BE A SET OF SIZE n, new imported
2145 Count the Hidden Sequences Python O(n) O(1) Medium math, THE WHOLE SEQUENCE IS PINNED BY ITS FIRST ELEMENT, new, amazon imported
2148 Count Elements With Strictly Smaller and Greater Elements Python O(n) O(1) Easy math, ANYTHING STRICTLY BETWEEN THE GLOBAL MIN AND MAX QUALIFIES, new imported
2152 Minimum Number of Lines to Cover Points Python O(2^n * n) O(2^n) Medium math, 🔒, BITMASK DP OVER UNCOVERED POINTS (n <= 10), new imported
2169 Count Operations to Obtain Zero Python O(log(min(num1, num2))) O(1) Easy math, THIS IS THE SUBTRACTIVE EUCLIDEAN ALGORITHM — BATCH THE SUBTRACTIONS, new imported
2171 Removing Minimum Number of Magic Beans Python O(n log n) O(n) Medium math, SORT, THEN TRY EVERY SURVIVING VALUE (it must be one of the beans[i]), new imported
2176 Count Equal and Divisible Pairs in an Array Python O(n^2) O(1) Easy math, DIRECT DOUBLE LOOP (n <= 100 -> at most ~5000 pairs), new imported
2177 Find Three Consecutive Integers That Sum to a Given Number Python O(1) O(1) Medium math, THE MIDDLE TERM IS num / 3, new imported
2180 Count Integers With Even Digit Sum Python O(log num) O(1) Easy math, MATH / COUNTING (every block of 10 holds exactly 5 even digit sums), new imported
2183 Count Array Pairs Divisible by K Python O(n log k + d(k)^2) O(d(k)) Hard math, GCD BUCKETS (only gcd(nums[i], k) matters for divisibility), new imported
2198 Number of Single Divisor Triplets Python O(n + 100^3) O(100) Medium math, 🔒, VALUES ARE <= 100 — ENUMERATE VALUE TRIPLES, NOT INDEX TRIPLES, new imported
2217 Find Palindrome With Fixed Length Python O(q * L), q = len(queries), L = intLength O(q) Medium math, MATH / CONSTRUCTION (a palindrome is fully decided by its left half), new imported
2221 Find Triangular Sum of an Array Python O(n^2) O(1) Medium math, IN-PLACE SIMULATION (Pascal-triangle folding), new imported
2235 Add Two Integers Python O(1) O(1) Easy math, DIRECT ARITHMETIC, new imported
2240 Number of Ways to Buy Pens and Pencils Python O(total / cost1) O(1) Medium math, FIX THE NUMBER OF PENS, COUNT THE PENCILS ARITHMETICALLY, new imported
2244 Minimum Rounds to Complete All Tasks Python O(n) O(n) Medium math, PER DIFFICULTY, GREEDILY USE AS MANY 3s AS POSSIBLE, new imported
2249 Count Lattice Points Inside a Circle Python O(circles * r^2) O(number of covered points) Medium math, THE COORDINATE SPACE IS TINY — COLLECT THE COVERED POINTS IN A SET, new imported
2262 Total Appeal of A String Python O(n) O(26) Hard math, CONTRIBUTION / RUNNING DP (sum over substrings ending at i), new imported
2280 Minimum Lines to Represent a Line Chart Python O(n log n) O(n) Medium math, SORT BY DAY, THEN COUNT SLOPE CHANGES USING CROSS PRODUCTS, new imported
2310 Sum of Numbers With Units Digit K Python O(1) O(1) Medium math, MATH / ENUMERATE THE SET SIZE (only the last digit constrains us), new imported
2338 Count the Number of Ideal Arrays Python O(log(maxValue) * maxValue * log(maxValue)) O(log(maxValue) * maxValue) Hard math, SPLIT THE ARRAY INTO ITS DISTINCT VALUES AND WHERE THEY CHANGE, new imported
2344 Minimum Deletions to Make Array Divisible Python O(n log n + m) O(n) Hard math, “DIVIDES EVERY numsDivide” IS THE SAME AS “DIVIDES THEIR GCD”, new imported
2376 Count Special Integers Python O(digits^2) O(digits) Hard math, COUNT BY DIGIT LENGTH, THEN WALK n’s DIGITS FIXING A COMMON PREFIX, new imported
2396 Strictly Palindromic Number Python O(1) O(1) Medium math, MATH (base n-2 is always a counter-example, so the answer is always false), new imported
2400 Number of Ways to Reach a Position After Exactly k Steps Python O(k) O(1) Medium math, PURE COMBINATORICS — CHOOSE WHICH STEPS GO RIGHT, new imported
2409 Count Days Spent Together Python O(1) O(1) Easy math, CONVERT EACH “MM-DD” TO A DAY-OF-YEAR, THEN INTERSECT TWO INTERVALS, new imported
2413 Smallest Even Multiple Python O(1) O(1) Easy math, lcm(2, n) — WHICH IS n IF n IS EVEN, ELSE 2n, new imported
2427 Number of Common Factors Python O(sqrt(min(a, b))) O(1) Easy math, THE COMMON FACTORS OF a AND b ARE EXACTLY THE DIVISORS OF gcd(a, b), new imported
2437 Number of Valid Clock Times Python O(24 + 60) = O(1) O(1) Easy math, ENUMERATION (hours and minutes are independent -> multiply the counts), new imported
2450 Number of Distinct Binary Strings After Applying Operations Python O(log n) for the modular power O(1) Medium math, 🔒, LINEAR ALGEBRA OVER GF(2) (the n - k + 1 flip windows are independent), new imported
2455 Average Value of Even Numbers That Are Divisible by Three Python O(n) O(n) Easy math, “EVEN AND DIVISIBLE BY 3” IS EXACTLY “DIVISIBLE BY 6”, new imported
2468 Split Message Based on Limit Python O(n log n) O(n) Hard math, TRY EACH PART COUNT k IN ORDER AND CHECK THE TOTAL CAPACITY, new imported
2469 Convert the Temperature Python O(1) O(1) Easy math, APPLY THE TWO CONVERSION FORMULAS, new imported
2481 Minimum Cuts to Divide a Circle Python O(1) O(1) Easy math, MATH / CASE SPLIT, new imported
2485 Find the Pivot Integer Python O(1) O(1) Easy math, SOLVE IT ALGEBRAICALLY — x^2 = n(n+1)/2, new imported
2514 Count Anagrams Python O(n) O(1) (alphabet is fixed at 26) Hard math, COMBINATORICS (multinomial coefficient per word) + MODULAR INVERSE, new imported
2520 Count the Digits That Divide a Number Python O(log num) O(1) Easy math, DIGIT ENUMERATION (peel digits off with divmod), new imported
2521 Distinct Prime Factors of Product of Array Python O(n * sqrt(m)) O(number of distinct primes <= m) (m = max(nums)) Medium math, TRIAL DIVISION + SET, new imported
2523 Closest Prime Numbers in Range Python O(right * log log right) O(right) Medium math, SIEVE OF ERATOSTHENES + ADJACENT PAIR SCAN, new imported
2525 Categorize Box According to Criteria Python O(1) O(1) Easy math, SIMULATION -> 2 INDEPENDENT FLAGS -> LOOKUP TABLE, new imported
2539 Count the Number of Good Subsequences Python O(n * 26) O(n) Medium math, 🔒, COMBINATORICS – FIX THE COMMON FREQUENCY, MULTIPLY OVER LETTERS, new imported
2543 Check if Point Is Reachable Python O(log(min(targetX, targetY))) O(1) Hard math, MATH / NUMBER THEORY (gcd is invariant up to powers of 2), new imported
2544 Alternating Digit Sum Python O(log n) O(log n) Easy math, SIMULATION (walk digits left -> right, flip the sign each step), new imported
2549 Count Distinct Numbers on Board Python O(1) O(1) Easy math, MATH (every x > 2 immediately spawns x - 1, so the board fills up), new imported
2550 Count Collisions of Monkeys on a Polygon Python O(log n) O(1) Medium math, MATH / COMPLEMENT COUNTING + FAST MODULAR POWER, new imported
2562 Find the Array Concatenation Value Python O(n log M) O(1) (M = max value in nums) Easy math, TWO POINTERS + MATH (digit shift), new imported
2568 Minimum Impossible OR Python O(n + log(max(nums))) O(n) Medium math, BRAINTEASER - THE ANSWER IS ALWAYS A POWER OF 2, new imported
2579 Count Total Number of Colored Cells Python O(1) O(1) Medium math, MATH (closed form for the diamond / Aztec shape), new imported
2582 Pass the Pillow Python O(1) O(1) Easy math, MATH (divmod on the half-period), new imported
2584 Split the Array to Make Coprime Products Python O(n * P + n) with P = 168 primes below 1000 O(n + distinct primes) Hard math, PRIME FACTORIZATION -> INTERVAL MERGING (sweep the furthest reach), new imported
2651 Calculate Delayed Arrival Time Python O(1) O(1) Easy math, MATH (modular clock arithmetic), new imported
2652 Sum Multiples Python O(n) O(1) Easy math, DIRECT SCAN, new imported
2731 Movement of Robots Python O(n log n) O(n) Medium math, COLLISIONS ARE A RELABELLING (pass-through) + SORT + PREFIX SUM, new imported
2739 Total Distance Traveled Python O(mainTank + additionalTank) O(1) Easy math, SIMULATION (BURN 5 LITERS AT A TIME), new imported
2749 Minimum Operations to Make the Integer Zero Python O(log(max(num1, num2))) O(1) Medium math, ENUMERATE THE OPERATION COUNT k (bit manipulation / brainteaser), new imported
2750 Ways to Split Array Into Good Subarrays Python O(n) O(1) Medium math, MULTIPLICATION PRINCIPLE (count the cut positions between consecutive 1s), new imported
2761 Prime Pairs With Target Sum Python O(n * log log n) O(n) Medium math, SIEVE OF ERATOSTHENES + ENUMERATE THE SMALLER PRIME, new imported
2778 Sum of Squares of Special Elements Python O(n) O(1) Easy math, DIRECT SCAN OVER THE DIVISORS OF n, new imported
2780 Minimum Index of a Valid Split Python O(n) O(1) Medium math, BOYER-MOORE MAJORITY VOTE + PREFIX COUNT SWEEP, new imported
2802 Find The K-th Lucky Number Python O(log k) O(log k) Medium math, 🔒, MATH / BINARY ENCODING (4 -> bit 0, 7 -> bit 1), new imported
2806 Account Balance After Rounded Purchase Python O(1) O(1) Easy math, MATH (ROUND-HALF-UP TO THE NEAREST MULTIPLE OF 10), new imported
2833 Furthest Point From Origin Python O(n) O(1) Easy math, MATH / COUNTING (fixed displacement + free moves), new imported
2861 Maximum Number of Alloys Python O(k * n * log(max_stock + budget)) O(1) Medium math, BINARY SEARCH ON THE ANSWER, PER MACHINE, new imported
3001 Minimum Moves to Capture The Queen Python O(1) O(1) Medium math, THE ANSWER IS ONLY EVER 1 OR 2 — SO JUST TEST FOR 1, new imported
3007 Maximum Number That Sum of the Prices Is Less Than or Equal to K Python O(log(hi) * log(hi)/x) O(1) Medium math, BINARY SEARCH ON num, WITH A CLOSED FORM FOR “SET BITS UP TO num”, new imported
3021 Alice and Bob Playing Flower Game Python O(1) O(1) Medium math, EVERY TURN REMOVES EXACTLY ONE FLOWER — SO ONLY THE PARITY MATTERS, new imported
3024 Type of Triangle Python O(1) O(1) Easy math, SORT FIRST — THEN ONE INEQUALITY DECIDES EXISTENCE, new imported
3032 Count Numbers With Unique Digits II Python O((b - a) * digits) O(1) Easy math, 🔒, b <= 1000, SO JUST TEST EVERY NUMBER, new imported
3047 Find the Largest Area of Square Inside Two Rectangles Python O(n^2) O(1) Medium math, THE BEST SQUARE ALWAYS LIVES IN SOME PAIRWISE INTERSECTION, new imported
3084 Count Substrings Starting and Ending with Given Character Python O(n) O(1) Medium math, PICK AN ORDERED PAIR OF c-POSITIONS (THE SAME ONE TWICE IS ALLOWED), new imported
3102 Minimize Manhattan Distances Python O(n log n) O(n) Hard math, ROTATE TO CHEBYSHEV — MANHATTAN MAX BECOMES TWO INDEPENDENT SPREADS, new imported
3115 Maximum Prime Difference Python O(n) O(1) Medium math, ONLY THE FIRST AND LAST PRIME POSITIONS MATTER, new imported
3128 Right Triangles Python O(m * n) O(m + n) Medium math, COUNT BY THE CORNER — THE CELL THAT SUPPLIES BOTH LEGS, new imported
3154 Find Number of Ways to Reach the K-th Stair Python O(log k * …) — about 60 binomials O(1) Hard math, THE UP-MOVES ARE FORCED — SO ONLY WHERE THE DOWN-MOVES GO IS FREE, new imported
3155 Maximum Number of Upgradable Servers Python O(n) O(n) Medium math, 🔒, SOLVE THE INEQUALITY FOR k INSTEAD OF SEARCHING FOR IT, new imported
3162 Find the Number of Good Pairs I Python O(n * m) O(1) Easy math, 50 x 50 PAIRS — TEST THE DIVISIBILITY DIRECTLY, new imported
3164 Find the Number of Good Pairs II Python O(n + max value * H(distinct)) O(max value) Medium math, DIVIDE OUT k, THEN SWEEP THE MULTIPLES OF EACH DISTINCT nums2 VALUE, new imported
3178 Find the Child Who Has the Ball After K Seconds Python O(1) O(1) Easy math, THE MOTION IS PERIODIC WITH PERIOD 2*(n-1) — FOLD, THEN REFLECT, new imported
3179 Find the N-th Value After K Seconds Python O(n * k) O(n) Medium math, EACH SECOND IS ONE IN-PLACE PREFIX-SUM SWEEP, new imported
3183 The Number of Ways to Make the Sum Python O(n) O(n) Medium math, 🔒, UNBOUNDED COIN COUNT FOR {1, 2, 6}, THEN ADD 0, 1 OR 2 FOURS BY HAND, new imported
3200 Maximum Height of a Triangle Python O(sqrt(red + blue)) O(1) Easy math, ONLY TWO ARRANGEMENTS EXIST — TRY BOTH AND SIMULATE, new imported
3222 Find the Winning Player in Coin Game Python O(1) O(1) Easy math, 115 HAS EXACTLY ONE DECOMPOSITION — 75 + 4 x 10, new imported
3227 Vowels Game in a String Python O(n) O(1) Medium math, ALICE WINS IFF THE STRING HOLDS AT LEAST ONE VOWEL, new imported
3232 Find if Digit Game Can Be Won Python O(n) O(1) Easy math, THE TWO CHOICES ARE COMPLEMENTARY — SO ALICE LOSES ONLY ON A TIE, new imported
3247 Number of Subsequences with Odd Sum Python O(n) O(1) Medium math, 🔒, THE SUM’S PARITY DEPENDS ONLY ON HOW MANY ODD ELEMENTS ARE TAKEN, new imported
3250 Find the Count of Monotonic Pairs I Python O(n * max value) O(max value) Hard math, arr2 IS DETERMINED BY arr1 — SO COUNT THE VALID arr1 SEQUENCES, new imported
3251 Find the Count of Monotonic Pairs II Python O(n * max value) O(max value) Hard math, SAME PREFIX-SUM DP AS LC 3250 — IT WAS ALREADY O(n * max), new imported
3270 Find the Key of the Numbers Python O(1) O(1) Easy math, PAD TO FOUR DIGITS, TAKE THE COLUMN-WISE MINIMUM, READ IT BACK, new imported
3272 Find the Count of Good Integers Python O(10^ceil(n/2) * n) O(number of multisets) Hard math, ENUMERATE THE PALINDROMES, THEN COUNT PERMUTATIONS PER DIGIT MULTISET, new imported
3274 Check if Two Chessboard Squares Have the Same Color Python O(1) O(1) Easy math, A SQUARE’S COLOUR IS THE PARITY OF (COLUMN + ROW), new imported
3312 Sorted GCD Pair Queries Python O(max log max + q log max) O(max) Hard math, COUNT PAIRS BY GCD WITH A DIVISOR SIEVE, THEN BINARY SEARCH THE PREFIX, new imported
3326 Minimum Division Operations to Make Array Non Decreasing Python O(max value log log max + n) O(max value) Medium math, DIVIDING BY THE GREATEST PROPER DIVISOR LEAVES THE SMALLEST PRIME FACTOR, new imported
3345 Smallest Divisible Digit Product I Python O(1) in practice O(1) Easy math, n AND t ARE TINY — WALK UPWARDS UNTIL THE PRODUCT DIVIDES, new imported
3360 Stone Removal Game Python O(1) O(1) Easy math, THE MOVE SIZES ARE FIXED — 10, 9, 8, … — SO JUST PLAY IT OUT, new imported
3395 Subsequences with a Unique Middle Mode I Python O(n * D) with D distinct values O(D) Hard math, FIX THE MIDDLE, COUNT BY HOW MANY COPIES OF IT WE TAKE, new imported
3405 Count the Number of Arrays with K Matching Adjacent Elements Python O(n + log n) O(1) Hard math, CLOSED-FORM COUNT — CHOOSE THE MATCHING POSITIONS, THEN FILL FREELY, new imported
3411 Maximum Subarray With Equal Products Python O(n^2 log(max)) O(1) Easy math, BRUTE FORCE EVERY SUBARRAY, GROWING PROD / GCD / LCM INCREMENTALLY, new imported
3416 Subsequences with a Unique Middle Mode II Python O(n) O(n) Hard math, 🔒, SAME COUNTING AS PART I, BUT THE SUM OVER y IS KEPT INCREMENTALLY, new imported
3426 Manhattan Distances of All Arrangements of Pieces Python O(mn) for the factorial table O(mn) Hard math, SWAP THE SUMMATION ORDER — EVERY CELL PAIR IS SEEN THE SAME NUMBER OF TIMES, new imported
3428 Maximum and Minimum Sums of at Most Size K Subsequences Python O(n log n) O(n) Medium math, SORT, THEN COUNT HOW OFTEN EACH ELEMENT IS THE MAX / THE MIN, new imported
3512 Minimum Operations to Make Array Sum Divisible by K Python O(n) O(1) Easy math, EACH OPERATION LOWERS THE SUM BY EXACTLY ONE, new imported
3513 Number of Unique XOR Triplets I Python O(1) after reading n O(1) Medium math, CLOSURE OF {1…n} UNDER XOR IS THE FULL POWER-OF-TWO BLOCK, new imported
3516 Find Closest Person Python O(1) O(1) Easy math, EQUAL SPEED MEANS TIME IS JUST DISTANCE, new imported
3519 Count Numbers with Non-Decreasing Digits Python O(L^2 + L * b) with L the base-b length O(L) Hard math, DIGIT DP IN BASE b, COUNTED WITH STARS-AND-BARS INSTEAD OF A STATE, new imported
3556 Sum of Largest Prime Substrings Python O(n^2 * sqrt(10^n)) with n <= 10 O(n^2) Medium math, ENUMERATE ALL SUBSTRINGS, DEDUPLICATE, TAKE THE TOP THREE, new imported
3560 Find Minimum Log Transportation Cost Python O(1) O(1) Easy math, AT MOST ONE CUT, AND THE CUT IS FORCED, new imported
3577 Count the Number of Computer Unlocking Permutations Python O(n) O(1) Medium math, EITHER COMPUTER 0 UNLOCKS EVERYTHING, OR NOTHING WORKS, new imported
3588 Find Maximum Area of a Triangle Python O(n) O(n) Medium math, THE AXIS-PARALLEL SIDE IS THE BASE; THE APEX IS A GLOBAL EXTREME, new imported
3596 Minimum Cost Path with Alternating Directions I Python O(1) O(1) Medium math, 🔒, PARITY INVARIANT ON (row + col) — ONLY THREE GRIDS ARE SOLVABLE, new imported
3602 Hexadecimal and Hexatrigesimal Conversion Python O(log n) O(log n) Easy math, ONE GENERIC BASE-CONVERSION HELPER, CALLED TWICE, new imported
3618 Split Array by Prime Indices Python O(n log log n) O(n) Medium math, SIEVE OF ERATOSTHENES + SIGNED SUM IN ONE PASS, new imported
3621 Number of Integers With Popcount-Depth Equal to K I Python O((log n)^2) O((log n)^2) Hard math, COLLAPSE THE DEPTH ONTO THE POPCOUNT, THEN COUNT BY POPCOUNT, new imported
3622 Check Divisibility by Digit Sum and Product Python O(log n) O(1) Easy math, DIGIT SCAN, new imported
3623 Count Number of Trapezoids I Python O(n) O(n) Medium math, COUNT HORIZONTAL SEGMENTS PER ROW, THEN PAIR ACROSS ROWS, new imported
3624 Number of Integers With Popcount-Depth Equal to K II Python O((n + q) * log n) O(n) Hard math, DEPTH IS TINY, SO KEEP ONE FENWICK TREE PER DEPTH, new imported
3625 Count Number of Trapezoids II Python O(n^2) O(n^2) Hard math, PAIR UP PARALLEL SEGMENTS, THEN UNDO THE PARALLELOGRAM DOUBLE COUNT, new imported
3648 Minimum Sensors to Cover Grid Python O(1) O(1) Medium math, THE CHEBYSHEV BALL IS A SQUARE, SO ROWS AND COLUMNS DECOUPLE, new imported
3658 GCD of Odd and Even Sums Python O(1) O(1) Easy math, CLOSED FORMS COLLAPSE THE GCD TO n, new imported
3659 Partition Array Into K-Distinct Groups Python O(n) O(n) Medium math, COUNTING ARGUMENT — n % k == 0 AND maxFreq <= n / k, new imported
3664 Two-Letter Card Game Python O(n + z) O(1) Medium math, MAXIMUM MATCHING IN TWO COMPLETE MULTIPARTITE GRAPHS SHARING “xx”, new imported
3666 Minimum Operations to Equalize Binary String Python O(n * alpha(n)) O(n) Hard math, COLLAPSE THE STATE TO “HOW MANY ZEROS” AND BFS OVER INTERVALS, new imported
3671 Sum of Beautiful Subsequences Python O(V log V + sum_x d(x) * log n) O(V + sum_x d(x)) Hard math, DIVISOR SUM + EULER’S PHI COLLAPSES THE “EXACTLY g” CONDITION, new imported
3677 Count Binary Palindromic Numbers Python O(log^2 n) O(log n) Hard math, A PALINDROME IS DETERMINED BY ITS FIRST HALF – COUNT HALVES, new imported

Pandas

# Title Solution Time Space Difficulty Note Status
2882 Drop Duplicate Rows Python O(n) O(n) Easy pandas, PANDAS drop_duplicates ON A SUBSET OF COLUMNS, new imported
2883 Drop Missing Data Python O(n) O(n) Easy pandas, PANDAS dropna RESTRICTED TO THE name COLUMN, new imported
2884 Modify Columns Python O(n) O(n) Easy pandas, VECTORISED COLUMN ARITHMETIC (in-place column assignment), new imported
2885 Rename Columns Python O(m) for m columns O(m) Easy pandas, PANDAS rename WITH AN OLD -> NEW COLUMN MAPPING, new imported
2886 Change Data Type Python O(n) O(n) Easy pandas, PANDAS astype ON A SINGLE COLUMN, new imported

Queue

# Title Solution Time Space Difficulty Note Status
1424 Diagonal Traverse II Python O(n) O(n) Medium queue, BUCKET BY (i + j) DIAGONAL KEY, new, google, fb imported
1499 Max Value of Equation Python O(n) O(n) Hard queue, MONOTONIC DEQUE (sliding window maximum), new, google imported
1696 Jump Game VI Python O(n) O(n) Medium queue, DP + MONOTONIC DEQUE (sliding-window MAXIMUM over the last k states), new, amazon, apple, uber imported
2398 Maximum Number of Robots Within Budget Python O(n) O(n) Hard queue, SLIDING WINDOW + MONOTONIC (DECREASING) DEQUE, new imported

Recursion

# Title Solution Time Space Difficulty Note Status
0761 Special Binary String Python, Java O(n^2logn) O(n^2) Hard recursion, recursively sort the balanced special substrings, good trick, new imported
1106 Parsing A Boolean Expression Python O(n) O(n) Hard recursion, STACK (evaluate the inner-most group on every ‘)’), new, amazon imported
2613 Beautiful Pairs Python O(n * log(n)^2) O(n) Hard recursion, 🔒, CLOSEST PAIR OF POINTS (DIVIDE & CONQUER) under the MANHATTAN metric, new imported

Simulation

# Title Solution Time Space Difficulty Note Status
1138 Alphabet Board Path Python O(n * (rows + cols)), n = len(target) O(n * (rows + cols)), for the output string Medium simulation, SIMULATION + move ORDER trick (handle the lonely ‘z’), new, google, amazon imported
1243 Array Transformation Python O(n * m), n = len(arr), m = max value O(n) Easy simulation, SIMULATION, new imported
2061 Number of Spaces Cleaning Robot Cleaned Python O(m * n) O(m * n) Medium simulation, 🔒, SIMULATION UNTIL A (cell, direction) STATE REPEATS, new, microsoft imported
2162 Minimum Cost to Set Cooking Time Python O(1) O(1) Medium simulation, ONLY TWO (minutes, seconds) ENCODINGS EXIST — COST THEM BOTH, new, google imported
2257 Count Unguarded Cells in the Grid Python O(m * n + guards * (m + n)) O(m * n) Medium simulation, RAY-CAST FROM EACH GUARD, STOPPING AT ANY OCCUPIED CELL, new imported
2303 Calculate Amount Paid in Taxes Python O(n) O(1) Easy simulation, SIMULATION (walk the brackets, clip each slice by the income), new imported
2532 Time to Cross a Bridge Python O((n + k) * log k) O(k) Hard simulation, EVENT SIMULATION WITH 4 HEAPS, new imported
2534 Time Taken to Cross the Door Python O(n + max(arrival)) O(n) Hard simulation, 🔒, TWO FIFO QUEUES + SECOND-BY-SECOND SIMULATION, new imported
2596 Check Knight Tour Configuration Python O(n^2) O(n^2) Medium simulation, INVERT THE GRID INTO A VISIT ORDER, THEN CHECK EACH STEP, new imported
2751 Robot Collisions Python O(n * log n) O(n) Hard simulation, SORT BY POSITION + MONOTONIC STACK SIMULATION (“asteroid collision”), new imported
2934 Minimum Operations to Maximize Last Elements in Arrays Python O(n) O(1) Medium simulation, CASE SPLIT ON THE LAST INDEX + GREEDY SCAN, new imported
3100 Water Bottles II Python O(sqrt(numBottles)) O(1) Medium simulation, DRINK EVERYTHING, THEN EXCHANGE WHILE THE EMPTIES STILL COVER THE PRICE, new imported
3168 Minimum Number of Chairs in a Waiting Room Python O(n) O(1) Easy simulation, THE ANSWER IS THE PEAK OCCUPANCY, new imported
3175 Find The First Player to win K Games in a Row Python O(n) O(1) Medium simulation, ONE SWEEP IS ENOUGH — AFTER IT, THE STRONGEST PLAYER NEVER LOSES, new imported
3248 Snake in Matrix Python O(len(commands)) O(1) Easy simulation, TRACK (row, col) AND ENCODE AT THE END, new imported
3412 Find Mirror Score of a String Python O(n) O(n) Medium simulation, ONE STACK OF UNMARKED INDICES PER LETTER, new imported
3433 Count Mentions Per User Python O(n log n + total tokens) O(numberOfUsers + n) Medium simulation, SORT THE EVENTS, KEEP AN “OFFLINE UNTIL” CLOCK PER USER, new imported
3507 Minimum Pair Removal to Sort Array I Python O(n^2) O(n) Easy simulation, DIRECT SIMULATION, new imported
3510 Minimum Pair Removal to Sort Array II Python O(n * log n) O(n) Hard simulation, DOUBLY LINKED LIST + LAZY MIN-HEAP + A COUNTER OF DESCENTS, new imported
3522 Calculate Score After Performing Instructions Python O(n) O(n) Medium simulation, SIMULATION WITH A VISITED SET, new imported
3561 Resulting String After Adjacent Removals Python O(n) O(n) Medium simulation, STACK — REPLAY THE REQUIRED LEFTMOST REMOVALS IN ONE PASS, new imported
3597 Partition String Python O(n * sqrt(n)) worst case O(n) Medium simulation, GREEDY SCAN WITH A SET OF ALREADY-EMITTED SEGMENTS, new imported
3608 Minimum Time for K Connected Components Python O(m * log(m) + (n + m) * alpha(n)) O(n) Medium simulation, REVERSE KRUSKAL — ADD EDGES BACK FROM THE LATEST TIME DOWN, new imported
3609 Minimum Moves to Reach Target in Grid Python O(log(tx) + log(ty)) O(1) Hard simulation, BACKWARD WALK — THE PREDECESSOR IS FORCED, new imported
3612 Process String with Special Operations I Python O(2^n) O(2^n) Medium simulation, DIRECT SIMULATION ON A CHARACTER LIST, new imported
3613 Minimize Maximum Component Cost Python O(m * log(m) + (n + m) * alpha(n)) O(n) Medium simulation, KRUSKAL — GROW FROM THE CHEAPEST EDGE UNTIL K COMPONENTS REMAIN, new imported
3614 Process String with Special Operations II Python O(n) O(1) Hard simulation, LENGTH SWEEP FORWARD, THEN WALK THE INDEX BACKWARDS, new imported
3616 Number of Student Replacements Python O(n) O(1) Medium simulation, 🔒, COUNT STRICT PREFIX MINIMA, new imported
3639 Minimum Time to Activate String Python O(n log n) O(n) Medium simulation, BINARY SEARCH ON TIME + COMPLEMENT COUNT OF STARRED SUBSTRINGS, new imported

Sort

# Title Solution Time Space Difficulty Note Status
1086 High Five Python O(n log n) O(n) Easy sort, 🔒, GROUP BY id (hash map) + keep the 5 biggest scores per student, new, amazon imported
1122 Relative Sort Array Python O(n log n) O(n) n = len(arr1) Easy sort, CUSTOM SORT KEY (rank from arr2, then value), new, google, amazon, fb, apple, microsoft imported
1356 Sort Integers by The Number of 1 Bits Python O(n log n) O(n) Easy sort, CUSTOM SORT KEY (popcount, value), new imported
1365 How Many Numbers Are Smaller Than the Current Number Python O(n log n) O(n) Easy sort, SORT + BINARY SEARCH (bisect_left), new, google, amazon, apple imported
1366 Rank Teams by Votes Python O(n*m + m^2 log m) O(m^2) Medium sort, COUNTING + CUSTOM SORT KEY, new, google, fb imported
1451 Rearrange Words in a Sentence Python O(n log n) O(n) Medium sort, STABLE SORT by word length, new, amazon imported
1509 Minimum Difference Between Largest and Smallest Value in Three Moves Python O(n log n) O(1) beyond the sort Medium sort, SORT + ENUMERATE THE 4 SPLITS, new, google, microsoft imported
1523 Count Odd Numbers in an Interval Range Python O(1) O(1) Easy sort, MATH / PREFIX COUNT (no loop needed), new imported
1561 Maximum Number of Coins You Can Get Python O(n log n) O(1) (in-place sort) Medium sort, GREEDY + SORT (always sacrifice the 3 smallest piles to Bob), new imported
1588 Sum of All Odd Length Subarrays Python O(n) O(1) Easy sort, CONTRIBUTION COUNTING (how many odd subarrays cover index i ?), new, google, amazon, apple imported
1608 Special Array With X Elements Greater Than or Equal X Python O(n log n) O(n) Easy sort, SORT + BINARY SEARCH the count of elements >= x, new, google imported
1620 Coordinate With Maximum Network Quality Python O(51 * 51 * m), m = len(towers) O(1) Medium sort, BRUTE FORCE over the bounded 51 x 51 integral grid, new imported
1621 Number of Sets of K Non-Overlapping Line Segments Python O(k) O(1) Medium sort, COMBINATORICS – the answer is C(n + k - 1, 2k), new, amazon imported
1630 Arithmetic Subarrays Python O(m * n) O(n) Medium sort, MIN / MAX / SET check per query (no sorting needed), new, google imported
1636 Sort Array by Increasing Frequency Python O(n log n) O(n) Easy sort, COUNTER + CUSTOM SORT KEY, new, google, amazon, fb imported
1637 Widest Vertical Area Between Two Points Containing No Points Python O(n log n) O(n) Easy sort, SORT BY X, take the largest gap between consecutive x values, new imported
1680 Concatenation of Consecutive Binary Numbers Python O(n) O(1) Medium sort, BIT MANIPULATION, INCREMENTAL SHIFT (never build the giant string), new, google, amazon imported
1685 Sum of Absolute Differences in a Sorted Array Python O(n) O(1) extra (excluding the output) Medium sort, PREFIX SUMS (sorted input kills the absolute value), new imported
1688 Count of Matches in Tournament Python O(1) O(1) Easy sort, COUNTING ARGUMENT (every match eliminates exactly one team), new imported
1716 Calculate Money in Leetcode Bank Python O(1) O(1) Easy sort, MATH (arithmetic series over whole weeks + the leftover days), new imported
1772 Sort Features by Popularity Python O(L + n log n), L = total length of responses, n = len(features) O(L) Medium sort, 🔒, COUNT WITH A HASH TABLE + STABLE SORT, new, amazon imported
1847 Closest Room Python O((n + k) log n) O(n) Hard sort, OFFLINE SORT BY SIZE (descending) + FENWICK OVER SORTED ROOM IDS, new, amazon imported
1859 Sorting the Sentence Python O(n) O(n) Easy sort, BUCKET PLACEMENT (the trailing digit IS the target index), new, google, amazon imported
1942 The Number of the Smallest Unoccupied Chair Python O(n log n) O(n) Medium sort, SORT BY ARRIVAL + TWO HEAPS (free chairs / occupied chairs by leave time), new, amazon imported
1996 The Number of Weak Characters in the Game Python O(n log n) O(n) for the sort Medium sort, SORT BY (attack DESC, defense ASC) + RUNNING MAX DEFENSE, new, google imported
2015 Average Height of Buildings in Each Segment Python O(m log m), m = len(buildings) O(m) Medium sort, 🔒, SWEEP LINE / DIFFERENCE ARRAY ON EVENT POINTS + MERGE EQUAL SEGMENTS, new imported
2070 Most Beautiful Item for Each Query Python O((n + m) log n) O(n) Medium sort, SORT BY PRICE + PREFIX MAX OF BEAUTY, THEN BINARY SEARCH PER QUERY, new imported
2089 Find Target Indices After Sorting Array Python O(n) O(1) beyond the output Easy sort, COUNT, DON’T SORT — THE POSITIONS FOLLOW FROM TWO TALLIES, new, google, fb imported
2158 Amount of New Area Painted Each Day Python O((n + RANGE) * alpha) O(RANGE) Hard sort, 🔒, UNION-FIND AS A “JUMP TO THE NEXT UNPAINTED UNIT” POINTER, new, google imported
2164 Sort Even and Odd Indices Independently Python O(n log n) O(n) Easy sort, SPLIT BY INDEX PARITY, SORT EACH SLICE, WRITE THEM BACK, new imported
2191 Sort the Jumbled Numbers Python O(n log n * d) O(n) Medium sort, SORT BY THE MAPPED VALUE, RELYING ON PYTHON’S STABLE SORT, new imported
2231 Largest Number After Digit Swaps by Parity Python O(d log d), d = number of digits O(d) Easy sort, SORT EACH PARITY CLASS DESCENDING, THEN REFILL IN PLACE, new imported
2233 Maximum Product After K Increments Python O((n + k) log n) O(n) Medium sort, GREEDY + MIN-HEAP (always feed the currently smallest element), new imported
2248 Intersection of Multiple Arrays Python O(total elements + k log k) O(n) Easy sort, SET INTERSECTION ACROSS EVERY ROW, THEN SORT, new imported
2251 Number of Flowers in Full Bloom Python O((F + P) log F) O(F) Hard sort, INCLUSION-EXCLUSION ON TWO SORTED ARRAYS OF ENDPOINTS, new imported
2343 Query Kth Smallest Trimmed Number Python O(q * n log n * L) O(n * L) Medium sort, SORT THE (TRIMMED STRING, INDEX) PAIRS PER QUERY, new imported
2418 Sort the People Python O(n log n) O(n) Easy sort, ZIP THE TWO ARRAYS AND SORT BY HEIGHT, DESCENDING, new imported
2497 Maximum Star Sum of a Graph Python O(V + E log E) O(V + E) Medium sort, SORT NEIGHBOR VALUES DESC + GREEDY TAKE TOP k, new imported
2512 Reward Top K Students Python O(n * L + n * log n) O(P + N + n) Medium sort, HASH SET SCORING + CUSTOM SORT, new imported
2545 Sort the Students by Their Kth Score Python O(m * log(m) * n) (row moves cost O(n)) O(m * n) for the output Medium sort, SORTING BY A KEY COLUMN, new imported
2679 Sum in a Matrix Python O(m * n * log(n)) O(1) extra (rows sorted in place) Medium sort, SORT EACH ROW DESCENDING, THEN TAKE THE COLUMN MAX, new imported
2740 Find the Value of the Partition Python O(n * log n) O(n) for the sort Medium sort, SORT + MIN ADJACENT DIFFERENCE, new imported
2785 Sort Vowels in a String Python O(n log n) O(n) Medium sort, EXTRACT -> SORT -> RE-INSERT, new imported
2792 Count Nodes That Are Great Enough Python O(n * k * log k) O(n * k) Hard sort, 🔒, POST-ORDER + BOUNDED MAX-HEAP OF THE k SMALLEST SUBTREE VALUES, new imported
3011 Find if Array Can Be Sorted Python O(n) O(1) Medium sort, EQUAL-POPCOUNT RUNS CAN BE SHUFFLED FREELY, BUT NEVER CROSS EACH OTHER, new imported
3025 Find the Number of Ways to Place People I Python O(n^2) O(n) Medium sort, SORT BY (x ASC, y DESC), THEN SWEEP KEEPING THE HIGHEST y SEEN, new imported
3027 Find the Number of Ways to Place People II Python O(n^2) O(n) Hard sort, SAME SWEEP AS LC 3025 — IT WAS ALREADY O(n^2), new imported
3081 Replace Question Marks in String to Minimize Its Value Python O(n log 26) O(n) Medium sort, THE VALUE ONLY DEPENDS ON THE MULTISET; THE ORDER ONLY ON TIE-BREAKING, new imported
3132 Find the Integer Added to Array II Python O(n log n) O(n) Medium sort, ONLY THREE CANDIDATE SHIFTS — THE SMALLEST SURVIVOR IS AMONG THE FIRST 3, new imported
3169 Count Days Without Meetings Python O(n log n) O(n) Medium sort, SORT BY START AND SWEEP, TRACKING THE FURTHEST DAY ALREADY BOOKED, new imported
3309 Maximum Possible Number by Binary Concatenation Python O(1) O(1) Medium sort, ONLY SIX ORDERINGS EXIST — BUILD THEM ALL, new imported
3394 Check if Grid can be Cut into Sections Python O(n log n) O(n) Medium sort, INTERVAL MERGING ON EACH AXIS INDEPENDENTLY, new imported
3431 Minimum Unlocked Indices to Sort Nums Python O(n) O(1) Medium sort, A BOUNDARY NEEDS UNLOCKING EXACTLY WHEN ITS PREFIX IS WRONG, new imported
3551 Minimum Swaps to Sort by Digit Sum Python O(n log n) O(n) Medium sort, PERMUTATION CYCLE DECOMPOSITION, new imported
3631 Sort Threats by Severity and Exploitability Python O(n log n) O(n) Medium sort, 🔒, SORT ON A COMPOSITE KEY (-score, id), new imported
3644 Maximum K to Sort a Permutation Python O(n) O(1) Medium sort, k MUST BE A SUBMASK OF EVERY MISPLACED VALUE — SO TAKE THEIR AND, new imported
3667 Sort Array By Absolute Value Python O(n log n) O(n) Easy sort, 🔒, SORT ON A DERIVED KEY, new imported

Stack

# Title Solution Time Space Difficulty Note Status
0726 Number of Atoms Python, Java O(n^2) O(n) Hard stack, stack of counters, parse nested parentheses, sort the atoms, new, google, amazon, fb, microsoft imported
0736 Parse Lisp Expression Python, Java O(n^2) O(n) Hard stack, recursive evaluation with a scope stack, complex, new, google imported
0770 Basic Calculator IV Python, Java O(n * t^2) O(n + t) Hard stack, parse the expression into polynomial terms, complex, new, google, amazon imported
1003 Check If Word Is Valid After Substitutions Python O(n) O(n) Medium stack, STACK, new imported
1019 Next Greater Node In Linked List Python O(n) O(n) Medium stack, MONOTONIC (DECREASING) STACK, new, google, amazon, fb, apple, microsoft, uber imported
1021 Remove Outermost Parentheses Python O(n) O(n), for the output Easy stack, DEPTH COUNTER (a stack of size 1), new, google, fb, apple imported
1063 Number of Valid Subarrays Python O(n) O(n) Hard stack, 🔒, MONOTONIC STACK (next strictly smaller element to the right), new imported
1190 Reverse Substrings Between Each Pair of Parentheses Python O(n^2) O(n) Medium stack, STACK of BUFFERS (simulation), new, amazon, fb, microsoft imported
1441 Build an Array With Stack Operations Python O(n) O(1) Medium stack, SIMULATION, new, google imported
1541 Minimum Insertions to Balance a Parentheses String Python O(n) O(1) Medium stack, GREEDY COUNTER (a “close” is the 2-char token ‘))’), new, fb, apple, microsoft imported
1856 Maximum Subarray Min-Product Python O(n) O(n) Medium stack, MONOTONIC STACK + PREFIX SUM (largest window where nums[i] is the min), new, uber imported
1944 Number of Visible People in a Queue Python O(n) O(n) Hard stack, MONOTONIC (DECREASING) STACK, SCANNING RIGHT -> LEFT, new, google, amazon, fb imported
1950 Maximum of Minimum Values in All Subarrays Python O(n) O(n) Medium stack, 🔒, MONOTONIC STACK (widest window where nums[i] is the minimum) + SUFFIX MAX, new, amazon imported
2197 Replace Non-Coprime Numbers in Array Python O(n log(max value)) amortised O(n) Hard stack, MONOTONIC-STYLE STACK — MERGE BACKWARDS UNTIL COPRIME, new imported
2281 Sum of Total Strength of Wizards Python O(n) O(n) Hard stack, MONOTONIC STACK FOR THE “I AM THE MINIMUM” RANGE + DOUBLE PREFIX SUMS, new imported
2282 Number of People That Can Be Seen in a Grid Python O(m * n) O(max(m, n)) Medium stack, 🔒, MONOTONIC DECREASING STACK, ONCE PER ROW AND ONCE PER COLUMN, new imported
2334 Subarray With Elements Greater Than Varying Threshold Python O(n) O(n) Hard stack, “EVERY ELEMENT > threshold / k” IS REALLY “THE MINIMUM > threshold / k”, new imported
2355 Maximum Number of Books You Can Take Python O(n) O(n) Hard stack, 🔒, MONOTONIC STACK + DP (optimal section ending at i is a 1-step staircase), new imported
2454 Next Greater Element IV Python O(n) O(n) Hard stack, TWO MONOTONIC STACKS — “WAITING FOR THE FIRST” AND “WAITING FOR THE SECOND”, new imported
2696 Minimum String Length After Removing Substrings Python O(n) O(n) Easy stack, STACK (adjacent-pair cancellation, same shape as “valid parentheses”), new imported
2735 Collecting Chocolates Python O(n^2) O(n) (n <= 1000 -> ~10^6 steps) Medium stack, ENUMERATE THE TOTAL NUMBER OF ROTATIONS + RUNNING PREFIX MIN, new imported
2736 Maximum Sum Queries Python O((n + m) * log n + m * log m) O(n + m) Hard stack, OFFLINE QUERIES (SORT BY x) + BINARY INDEXED TREE (MAX) OVER nums2, new imported
2764 is Array a Preorder of Some ‌Binary Tree Python O(n) O(n) Medium stack, 🔒, MONOTONIC “ANCESTOR PATH” STACK, new imported
2832 Maximal Range That Each Element Is Maximum in It Python O(n) O(n) Medium stack, 🔒, MONOTONIC STACK (previous greater / next greater element), new imported
3113 Find the Number of Subarrays Where Boundary Elements Are Maximum Python O(n) O(n) Hard stack, MONOTONIC STACK OF (VALUE, HOW MANY COPIES ARE STILL “VISIBLE”), new imported
3174 Clear Digits Python O(n) O(n) Easy stack, A STACK — A DIGIT ALWAYS CANCELS WHATEVER IS ON TOP, new imported
3676 Count Bowl Subarrays Python O(n) O(n) Medium stack, MONOTONIC STACK — COUNT “MUTUALLY VISIBLE” INDEX PAIRS, new imported

String

# Title Solution Time Space Difficulty Note Status
0068 Text Justification Python, Java O(n * w) O(w) excluding output Hard string, greedy line packing then distribute spaces, complex, google, new, amazon, fb, apple, microsoft, uber, linkedin imported
0420 Strong Password Checker Python, Java O(n) O(n) Hard string, case analysis on length, greedy replace/insert/delete, complex, new, google, amazon, fb, apple, microsoft, uber imported
0481 Magical String Python, Java O(n) O(n) Medium string, generate the magical string with two pointers, good trick, new, google imported
0500 Keyboard Row Python, Java O(l) O(1) Easy string, map each letter to its keyboard row, hashset, basic, new imported
0527 Word Abbreviation Python, Java O(nlogn * l) O(n * l) Hard string, 🔒, group by (length, first, last) and resolve collisions with a longer prefix, Trie, new, google, uber imported
0555 Split Concatenated Strings Python, Java O(l * (l + n)) O(l) Medium string, try each string reversed or not, then cut at the best position, good trick, new imported
0709 To Lower Case Python, Java O(n) O(n) Easy string, shift by 32 or use a lookup table, bit manipulation, basic, new, google, amazon, apple imported
0839 Similar String Groups Python, Java O(n^2 * m) O(n) Hard string, union find over similar pairs, LC 200, good trick, new, google, amazon, fb imported
1016 Binary String With Substrings Representing 1 To N Python O(L * 30), L = len(s) O(L * 30) Medium string, ENUMERATE the SUBSTRINGS, not the numbers, new, google imported
1056 Confusing Number Python O(d), d = number of digits O(1) Easy string, 🔒, DIGIT MAP + BUILD THE ROTATED NUMBER, new, google imported
1061 Lexicographically Smallest Equivalent String Python O((n + m) * a(26)), n = len(s1), m = len(baseStr) O(26) Medium string, 🔒, UNION FIND (26 letters), root of a group is always its SMALLEST letter, new imported
1078 Occurrences After Bigram Python O(n) O(n) Easy string, SPLIT + sliding window of size 3, new, google imported
1100 Find K-Length Substrings With No Repeated Characters Python O(n) O(1) Medium string, 🔒, SLIDING WINDOW (fixed size k) + counter, new, amazon imported
1108 Defanging an IP Address Python O(n) O(n) Easy string, STRING REPLACE, new, google, amazon, fb, apple imported
1177 Can Make Palindrome from Substring Python O(n + m) O(n) Medium string, PREFIX XOR BITMASK (parity of each letter count), new imported
1178 Number of Valid Words for Each Puzzle Python O(L + m * 2^7), L = total length of words, m = len(puzzles) O(n) Hard string, BITMASK + HASH TABLE + SUBSET ENUMERATION, new imported
1233 Remove Sub-Folders from the Filesystem Python O(n * L log n), L = max path length O(n) Medium string, SORT + PREFIX CHECK, new, google, amazon, fb, apple imported
1271 Hexspeak Python O(log n) O(log n) Easy string, STRING + BASE CONVERSION, new imported
1309 Decrypt String from Alphabet to Integer Mapping Python O(n) O(n) Easy string, simulation, scan left -> right and look ahead for ‘#’, new, amazon imported
1324 Print Words Vertically Python O(n * m) O(n * m) n = #words, m = longest word length Medium string, MATRIX TRANSPOSE with padding, then right-strip, new imported
1328 Break a Palindrome Python O(n) O(n) Medium string, GREEDY (first non-‘a’ in the left half -> ‘a’, else last char -> ‘b’), new, amazon, fb imported
1332 Remove Palindromic Subsequences Python O(n) O(n) Easy string, STRING + MATH, new, amazon imported
1347 Minimum Number of Steps to Make Two Strings Anagram Python O(n) O(1), at most 26 keys Medium string, COUNTER (count the surplus characters in t), new, amazon, microsoft imported
1370 Increasing Decreasing String Python O(26 * n) O(n) Easy string, COUNTING (simulate one full up-then-down sweep at a time), new, google, amazon imported
1371 Find the Longest Substring Containing Vowels in Even Counts Python O(n) O(1) (at most 32 mask entries) Medium string, PREFIX XOR MASK + FIRST-SEEN HASH TABLE, new imported
1374 Generate a String With Characters That Have Odd Counts Python O(n) O(n) Easy string, CONSTRUCTION by parity of n, new imported
1392 Longest Happy Prefix Python O(n) O(n) Hard string, KMP FAILURE FUNCTION (longest proper prefix that is also a suffix), new, google, amazon, microsoft imported
1408 String Matching in an Array Python O(n^2 * L^2), L = max word length O(n) Easy string, BRUTE FORCE (n is tiny : n <= 100, len <= 30), new, amazon imported
1410 HTML Entity Parser Python O(n * L), L = 7 (longest entity) O(n) Medium string, HASH TABLE + LEFT-TO-RIGHT SCAN, new, amazon imported
1417 Reformat The String Python O(n) O(n) Easy string, SPLIT BY TYPE + INTERLEAVE (the longer group must start), new, google imported
1422 Maximum Score After Splitting a String Python O(n) O(1) Easy string, RUNNING COUNTS (one sweep of the cut point), new, google imported
1446 Consecutive Characters Python O(n) O(1) Easy string, ONE PASS RUN LENGTH (track the current run, keep the best), new, google, apple imported
1455 Check If a Word Occurs As a Prefix of Any Word in a Sentence Python O(m * n) O(m) Easy string, SPLIT + str.startswith, return the FIRST (1-indexed) hit, new, amazon imported
1496 Path Crossing Python O(n) O(n) Easy string, HASH SET (record every visited coordinate), new, google, amazon imported
1507 Reformat Date Python O(1) O(1) Easy string, STRING PARSING (split into 3 tokens, normalise each), new imported
1528 Shuffle String Python O(n) O(n) Easy string, SCATTER INTO A RESULT BUFFER, new, google, fb, apple imported
1529 Minimum Suffix Flips Python O(n) O(1) Medium string, GREEDY LEFT-TO-RIGHT (count boundaries between blocks), new imported
1540 Can Convert String in K Moves Python O(n) O(26) Medium string, BUCKET BY REQUIRED SHIFT AMOUNT (mod 26), new imported
1542 Find Longest Awesome Substring Python O(10 * n) O(2^10) Hard string, PREFIX PARITY BITMASK + FIRST-OCCURRENCE TABLE, new imported
1545 Find Kth Bit in Nth Binary String Python O(n) O(1) Medium string, FOLD k BACK INTO THE PREVIOUS STRING (no string is ever built), new imported
1554 Strings Differ by One Character Python O(n * m) O(n * m), n = #words, m = word length Medium string, ROLLING HASH (hash of a word with one position “blanked out”), new, google, fb imported
1556 Thousand Separator Python O(d) O(d), d = number of digits Easy string, STRING (chop the decimal form into 3-digit groups from the right), new, uber imported
1576 Replace All ?'s to Avoid Consecutive Repeating Characters Python O(n) O(n) Easy string, GREEDY (three letters are always enough), new, google, microsoft imported
1592 Rearrange Spaces Between Words Python O(n) O(n) Easy string, STRING (count the spaces, then spread them evenly), new, google imported
1598 Crawler Log Folder Python O(n) O(1) Easy string, COUNTER (only the depth matters, never the folder names), new imported
1624 Largest Substring Between Two Equal Characters Python O(n) O(26) Easy string, HASH TABLE (remember the FIRST index of every character), new, google imported
1638 Count Substrings That Differ by One Character Python O(m * n * min(m, n)) O(1) ; m, n <= 100 Medium string, PIVOT ON THE MISMATCH, then expand both ways, new imported
1662 Check If Two String Arrays are Equivalent Python O(n + m) on total characters O(n + m) Easy string, STRING CONCAT (the array is just a chunked representation of one string), new, fb, apple imported
1668 Maximum Repeating Substring Python O(n^2 / m * m) = O(n^2) with n = len(sequence) O(n) Easy string, BRUTE FORCE SEARCH DOWNWARD (n <= 100 so k is at most 100), new, uber imported
1678 Goal Parser Interpretation Python O(n) O(n) Easy string, SINGLE PASS PARSE (the token is decided by the char after ‘(’), new, google, apple imported
1684 Count the Number of Consistent Strings Python O(A + sum(len(words[i]))) O(A) Easy string, SET CONTAINMENT (a word is consistent iff its char set is a subset), new, google, apple imported
1694 Reformat Phone Number Python O(n) O(n) Easy string, STRING SIMULATION DRIVEN BY len(digits) % 3, new imported
1698 Number of Distinct Substrings in a String Python O(n * A) with A = alphabet size O(n * A) Medium string, 🔒, SUFFIX AUTOMATON (answers the O(n) follow-up, not the O(n^2) set dump), new imported
1704 Determine if String Halves Are Alike Python O(n) O(1) (the vowel set is a fixed 10 chars) Easy string, COUNTING (single pass, one running balance instead of two counters), new imported
1763 Longest Nice Substring Python O(n^2) worst case O(n) Easy string, DIVIDE AND CONQUER ON A “BAD” CHARACTER, new, microsoft imported
1784 Check if Binary String Has at Most One Segment of Ones Python O(n) O(1) Easy string, LOOK FOR THE PATTERN “01”, new imported
1790 Check if One String Swap Can Make Strings Equal Python O(n) O(1) Easy string, COLLECT THE MISMATCHING POSITIONS (there must be exactly 0 or 2), new, fb imported
1796 Second Largest Digit in a String Python O(n) O(1) Easy string, TRACK THE TWO LARGEST DISTINCT DIGITS IN ONE PASS, new imported
1805 Number of Different Integers in a String Python O(n) O(n) Easy string, SCAN + STRIP LEADING ZEROS, STORE AS STRING IN A SET, new imported
1813 Sentence Similarity III Python O(n) O(n) Medium string, TWO POINTERS ON WORD LISTS (common prefix + common suffix must cover, new, google imported
1816 Truncate Sentence Python O(n) O(1) extra (O(n) for the returned slice) Easy string, SCAN AND CUT AT THE k-TH SPACE (no split / join needed), new imported
1832 Check if the Sentence Is Pangram Python O(n) O(1) Easy string, BITMASK OF SEEN LETTERS (26 bits, one per letter), new, amazon, fb, apple imported
1844 Replace All Digits with Characters Python O(n) O(n) Easy string, IN-PLACE CHARACTER ARITHMETIC ON THE ODD INDICES, new, google imported
1854 Maximum Population Year Python O(n + Y), Y = 101 year slots O(Y) Easy string, DIFFERENCE ARRAY / SWEEP LINE (years are bounded to 1950…2050), new, fb, microsoft imported
1858 Longest Word With All Prefixes Python O(L + n log n), L = total length of all words O(L) Medium string, 🔒, SORT BY LENGTH + INCREMENTAL DP (“good” set), new, google imported
1876 Substrings of Size Three with Distinct Characters Python O(n) O(1) Easy string, FIXED-SIZE SLIDING WINDOW (the window is only 3 chars wide), new imported
1880 Check if Word Equals Summation of Two Words Python O(L) O(1) Easy string, HORNER’S RULE (build the decimal value digit by digit), new imported
1903 Largest Odd Number in String Python O(n) O(1) extra (the slice is the returned answer) Easy string, GREEDY (keep the whole prefix up to the LAST odd digit), new imported
1910 Remove All Occurrences of a Substring Python O(n * m) O(n) Medium string, STACK (one pass, pop the tail whenever it just became part), new, google, amazon, microsoft imported
1933 Check if String Is Decomposable Into Value-Equal Substrings Python O(n) O(1) Easy string, 🔒, GROUP EQUAL RUNS, THEN LOOK AT EACH RUN LENGTH MOD 3, new imported
1935 Maximum Number of Words You Can Type Python O(n) O(26) Easy string, HASH SET OF BROKEN KEYS + SET DISJOINTNESS PER WORD, new imported
1957 Delete Characters to Make Fancy String Python O(n) O(n) for the output (O(1) extra) Easy string, GREEDY / SIMULATION (keep at most 2 of every run), new imported
1961 Check If String Is a Prefix of Array Python O(n), n = len(s) O(1) Easy string, LINEAR SCAN (match words against s with a moving cursor), new, uber imported
1967 Number of Strings That Appear as Substrings in Word Python O(n * m), n = len(patterns), m = len(word) O(1) Easy string, DIRECT SUBSTRING CHECK, new, uber imported
1974 Minimum Time to Type Word Using Special Typewriter Python O(n) O(1) Easy string, GREEDY (each hop is independent -> take the shorter arc), new imported
2000 Reverse Prefix of Word Python O(n) O(n) Easy string, FIND THE FIRST OCCURRENCE, THEN SLICE-REVERSE, new imported
2042 Check if Numbers Are Ascending in a Sentence Python O(n) O(n) Easy string, SPLIT ON SPACE, KEEP THE PREVIOUS NUMBER, new, apple imported
2047 Number of Valid Words in a Sentence Python O(n) O(n) Easy string, TOKENIZE, THEN CHECK THE THREE RULES DIRECTLY, new imported
2081 Sum of k-Mirror Numbers Python O(#candidates * digits) O(digits) Hard string, GENERATE BASE-10 PALINDROMES IN ORDER, THEN TEST BASE-k, new, fb imported
2103 Rings and Rods Python O(n) O(1) — at most 10 rods, 3 colours Easy string, A SET OF COLOURS PER ROD, new, google imported
2108 Find First Palindromic String in the Array Python O(n * L) O(L) Easy string, LINEAR SCAN, RETURN ON THE FIRST MATCH, new imported
2109 Adding Spaces to a String Python O(n) O(n) Medium string, CUT THE STRING AT THE GIVEN INDICES AND JOIN WITH SPACES, new, amazon imported
2114 Maximum Number of Words Found in Sentences Python O(total characters) O(1) Easy string, WORD COUNT = SPACE COUNT + 1, new, google imported
2116 Check if a Parentheses String Can Be Valid Python O(n) O(1) Medium string, TWO GREEDY SWEEPS — BEST CASE FROM EACH SIDE, new, amazon imported
2124 Check if All A’s Appears Before All B’s Python O(n) O(1) Easy string, THE FORBIDDEN PATTERN IS THE SUBSTRING “ba”, new imported
2129 Capitalize the Title Python O(n) O(n) Easy string, SPLIT, APPLY THE LENGTH RULE PER WORD, JOIN BACK, new imported
2131 Longest Palindrome by Concatenating Two Letter Words Python O(n) O(n) Medium string, PAIR EACH WORD WITH ITS REVERSE; ONE DOUBLE LETTER MAY SIT IN THE MIDDLE, new, google imported
2135 Count Words Obtained After Adding a Letter Python O((S + T) * 26) O(S) Medium string, LETTERS ARE DISTINCT -> EACH WORD IS JUST A 26-BIT SET, new, google imported
2138 Divide a String Into Groups of Size k Python O(n) O(n) Easy string, SLICE IN STEPS OF k, PAD THE LAST CHUNK, new imported
2156 Find Substring With Given Hash Value Python O(n) O(1) Hard string, ROLLING HASH — SLIDE RIGHT-TO-LEFT TO AVOID A MODULAR INVERSE, new imported
2157 Groups of Strings Python O(n * 26^2 * alpha) O(n) Hard string, EACH WORD IS A 26-BIT SET -> UNION-FIND OVER THE MASKS, new imported
2168 Unique Substrings With Equal Digit Frequency Python O(n^2) O(n^2) worst case for the set of hashes Medium string, 🔒, EXPAND EVERY START, TRACK THE COUNTS INCREMENTALLY, DEDUPE BY HASH, new imported
2185 Counting Words With a Given Prefix Python O(n * len(pref)) O(1) Easy string, COUNT THE WORDS WHOSE startswith() IS TRUE, new imported
2186 Minimum Number of Steps to Make Two Strings Anagram II Python O(len(s) + len(t)) O(26) Medium string, SYMMETRIC DIFFERENCE OF THE TWO LETTER COUNTS, new imported
2211 Count Collisions on a Road Python O(n) O(n) Medium string, ONLY THE CARS THAT ESCAPE NEVER COLLIDE — STRIP THEM AND COUNT, new imported
2213 Longest Substring of One Repeating Character Python O((n + k) log n) O(n) Hard string, SEGMENT TREE WHERE EACH NODE KEEPS PREFIX / SUFFIX / BEST RUNS, new imported
2223 Sum of Scores of Built Strings Python O(n) O(n) Hard string, Z-ALGORITHM (every si is a SUFFIX of s, so score(si) = z[n - i]), new imported
2232 Minimize Result by Adding Parentheses to Expression Python O(m * n * L), m,n = lengths of the two numbers (<= 10 total) O(L) Medium string, BRUTE FORCE ENUMERATION (the string is at most 10 chars), new imported
2243 Calculate Digit Sum of a String Python O(n log n) rounds-wise O(n) Easy string, DIRECT SIMULATION OF THE ROUNDS, new imported
2255 Count Prefixes of a Given String Python O(n * len(s)) O(1) Easy string, COUNT THE WORDS THAT s STARTS WITH, new imported
2264 Largest 3-Same-Digit Number in String Python O(10 * n) O(1) Easy string, ENUMERATE THE 10 CANDIDATES FROM BIG TO SMALL, new imported
2269 Find the K-Beauty of a Number Python O(d * k), d = number of digits (<= 10) O(d) Easy string, SLIDING WINDOW OVER THE DECIMAL STRING, new imported
2272 Substring With Largest Variance Python O(26 * 26 * n) O(1) Hard string, KADANE PER ORDERED LETTER PAIR (a = +1, b = -1, b must appear), new imported
2273 Find Resultant Array After Removing Anagrams Python O(n * L log L) O(n) Easy string, KEEP ONLY THE FIRST OF EACH RUN OF MUTUALLY-ANAGRAM NEIGHBOURS, new imported
2278 Percentage of Letter in String Python O(n) O(1) Easy string, INTEGER ARITHMETIC — MULTIPLY BEFORE DIVIDING, new imported
2288 Apply Discount to Prices Python O(n) O(n) Medium string, TOKENIZE ON SPACES AND REWRITE ONLY THE WORDS THAT ARE PRICES, new imported
2299 Strong Password Checker II Python O(n) O(1) Easy string, CHECK THE SIX RULES DIRECTLY, new imported
2301 Match Substring After Replacement Python O(len(s) * len(sub)) O(len(mappings)) Hard string, PRECOMPUTE “WHAT CAN EACH sub CHARACTER BECOME”, THEN SLIDE, new imported
2315 Count Asterisks Python O(n) O(1) Easy string, PARITY TOGGLE (one scan, a single “am I inside a pair?” flag), new imported
2381 Shifting Letters II Python O(n + len(shifts)) O(n) Medium string, DIFFERENCE ARRAY — EACH SHIFT IS A RANGE +1 OR -1, new imported
2414 Length of the Longest Alphabetical Continuous Substring Python O(n) O(1) Medium string, RUN LENGTH OF “EACH CHARACTER IS THE PREVIOUS ONE PLUS 1”, new imported
2416 Sum of Prefix Scores of Strings Python O(total characters) O(total characters) Hard string, TRIE WHERE EACH NODE COUNTS HOW MANY WORDS PASS THROUGH IT, new imported
2490 Circular Sentence Python O(n) O(n) Easy string, CHECK EVERY WORD AGAINST THE NEXT ONE, WRAPPING AT THE END, new imported
2496 Maximum Value of a String in an Array Python O(n * L) O(1) Easy string, STRING SCAN + MAX, new imported
2575 Find the Divisibility Array of a String Python O(n) O(1) beyond the output Medium string, ROLLING REMAINDER (Horner’s rule under a modulus), new imported
2586 Count the Number of Vowel Strings in Range Python O(right - left + 1) O(1) Easy string, SIMULATION (scan the inclusive window and test both ends), new imported
2678 Number of Senior Citizens Python O(n) O(1) Easy string, FIXED FIELD SLICING, new imported
2710 Remove Trailing Zeros From a String Python O(n) O(1) beyond the output Easy string, SCAN FROM THE RIGHT, new imported
2729 Check if The Number is Fascinating Python O(1) O(1) (the string is at most ~12 chars) Easy string, STRING CONCAT + SORT, new imported
2788 Split Strings by Separator Python O(n * m) O(n * m) for the output Easy string, SPLIT + FILTER EMPTIES, new imported
2800 Shortest String That Contains Three Strings Python O(n^2) O(n) n = max length of the three strings Medium string, ENUMERATE THE 6 PERMUTATIONS + GREEDY PAIRWISE MERGE, new imported
2810 Faulty Keyboard Python O(n) O(n) Easy string, DEQUE + ORIENTATION FLAG (LAZY REVERSAL), new imported
2828 Check if a String Is an Acronym of Words Python O(n) O(1) Easy string, SIMULATION (length check + pairwise first-letter compare), new imported
2843 Count Symmetric Integers Python O((high - low) * log(high)) O(log(high)) Easy string, BRUTE FORCE ENUMERATION over [low, high], new imported
3019 Number of Changing Keys Python O(n) O(n) Easy string, CASE-FOLD FIRST, THEN COUNT ADJACENT MISMATCHES, new imported
3023 Find Pattern in Infinite Stream I Python O(N * m) over N read bits O(m) Medium string, 🔒, ROLLING WINDOW OF THE LAST len(pattern) BITS, new imported
3029 Minimum Time to Revert Word to Initial State I Python O(n^2 / k) O(n) Medium string, THE ADDED CHARACTERS ARE FREE — ONLY THE SURVIVING SUFFIX MATTERS, new imported
3031 Minimum Time to Revert Word to Initial State II Python O(n) O(n) Hard string, SAME CONDITION AS LC 3029, BUT ANSWERED WITH THE Z-FUNCTION, new imported
3034 Number of Subarrays That Match a Pattern I Python O(n * m) O(n) Medium string, TURN nums INTO ITS SIGN SEQUENCE, THEN LOOK FOR THE PATTERN IN IT, new imported
3036 Number of Subarrays That Match a Pattern II Python O(n + m) O(n + m) Hard string, SIGN SEQUENCE + KMP, new imported
3037 Find Pattern in Infinite Stream II Python O(N + m) over N read bits O(m) Hard string, 🔒, KMP AS A STREAMING AUTOMATON — NO NEED TO STORE THE STREAM, new imported
3042 Count Prefix and Suffix Pairs I Python O(n^2 * L) O(1) Easy string, 50 WORDS OF LENGTH 10 — CHECK EVERY ORDERED PAIR DIRECTLY, new imported
3043 Find the Length of the Longest Common Prefix Python O((n + m) * digits) O(n * digits) Medium string, PUT EVERY PREFIX OF arr1 IN A SET, THEN WALK arr2’S PREFIXES, new imported
3045 Count Prefix and Suffix Pairs II Python O(sum of word lengths) O(sum of word lengths) Hard string, TRIE KEYED ON PAIRS (k-th FROM THE FRONT, k-th FROM THE BACK), new imported
3076 Shortest Uncommon Substring in an Array Python O(n^2 * L^3) O(L^2) Medium string, THE INPUT IS TINY — ENUMERATE SUBSTRINGS SHORTEST-FIRST, new imported
3110 Score of a String Python O(n) O(1) Easy string, SUM |ord(s[i]) - ord(s[i-1])| OVER THE ADJACENT PAIRS, new imported
3136 Valid Word Python O(n) O(1) Easy string, FOUR INDEPENDENT CHECKS IN ONE PASS, new imported
3163 String Compression III Python O(n) O(n) Medium string, WALK THE RUNS, EMITTING THEM IN CHUNKS OF AT MOST 9, new imported
3210 Find the Encrypted String Python O(n) O(n) Easy string, A CYCLIC SHIFT OF THE POSITIONS, NOT OF THE ALPHABET, new imported
3271 Hash Divided String Python O(n) O(n / k) Medium string, SUM EACH BLOCK’S LETTER INDICES, TAKE IT MOD 26, MAP BACK, new imported
3280 Convert Date to Binary Python O(1) O(1) Easy string, SPLIT ON ‘-’, CONVERT EACH FIELD, RE-JOIN, new imported
3303 Find the Occurrence of First Almost Equal Substring Python O(n + m) O(n + m) Hard string, MATCH THE PATTERN FROM BOTH ENDS — ONE MISMATCH MAY SIT IN THE MIDDLE, new imported
3324 Find the Sequence of Strings Appeared on the Screen Python O(n^2) for the strings produced O(n^2) Medium string, BUILD LEFT TO RIGHT — EACH CHARACTER COSTS ONE APPEND PLUS SOME BUMPS, new imported
3340 Check Balanced String Python O(n) O(1) Easy string, ONE RUNNING DIFFERENCE, ALTERNATING THE SIGN, new imported
3407 Substring Matching Pattern Python O(n^3) worst case on tiny inputs (n <= 50) O(n) Easy string, SPLIT AT THE STAR, ANCHOR THE PREFIX, THEN LOOK RIGHT, new imported
3529 Count Cells in Overlapping Horizontal and Vertical Substrings Python O(m * n) O(m * n) Medium string, FLATTEN THE GRID BOTH WAYS AND RUN KMP ON THE TWO STRINGS, new imported
3571 Find the Shortest Superstring II Python O(n^2) O(n) Easy string, 🔒, MAXIMUM PREFIX / SUFFIX OVERLAP, new imported
3582 Generate Tag for Video Caption Python O(n) O(n) Easy string, SPLIT ON WHITESPACE, THEN RE-CASE EACH WORD BY ITS POSITION, new imported
3598 Longest Common Prefix Between Adjacent Strings After Removals Python O(total length) O(n) Medium string, PREFIX / SUFFIX MAXIMA OVER THE ORIGINAL ADJACENT PAIRS, new imported
3606 Coupon Code Validator Python O(n * L + n * log(n)) O(n) Easy string, FILTER + SORT ON THE (CATEGORY, CODE) KEY, new imported

Tree

# Title Solution Time Space Difficulty Note Status
0428 Serialize and Deserialize N-ary Tree Python, Java O(n) O(n) Hard tree, 🔒, LC 297, serialize with child counts or sentinels, dfs / bfs, new, google, amazon, fb, apple, microsoft, uber, linkedin imported
0431 Encode N-ary Tree to Binary Tree Python, Java O(n) O(n) Hard tree, 🔒, first-child / next-sibling encoding, good trick, new, microsoft imported
0558 Logical OR of Two Binary Grids Represented as Quad-Trees Python, Java O(n1 + n2) O(logn) Medium tree, recursive quad-tree merge, LC 427, new, google, apple imported
0559 Maximum Depth of N-ary Tree Python, Java O(n) O(h) Easy tree, LC 104 for n-ary trees, dfs, bfs, good basic, new, google, amazon, microsoft imported
0589 N-ary Tree Preorder Traversal Python, Java O(n) O(h) Easy tree, LC 144 for n-ary trees, iterative with a stack, new, apple, microsoft imported
0590 N-ary Tree Postorder Traversal Python, Java O(n) O(h) Medium tree, LC 145 for n-ary trees, reverse-preorder trick, new, amazon imported
0685 Redundant Connection II Python, Java O(n * a(n)) O(n) Hard tree, LC 684, union find with the two-parent case, good trick, new, dfs, bfs, google, amazon imported
0699 Falling Squares Python, Java O(n^2) O(n) Hard tree, coordinate compression + segment tree, or an O(n^2) interval scan, new, array, ordered set, fb, uber imported
0850 Rectangle Area II Python, Java O(n^2) O(n) Hard tree, sweep line + coordinate compression, segment tree, LC 218, new, array, scan line, google imported
0993 Cousins in Binary Tree Python, Java O(n) O(h) Easy tree, LC 2641, dfs / bfs tracking depth and parent, good basic, new, google, amazon, fb, microsoft, bloomberg imported
0998 Maximum Binary Tree II Python, Java O(h) O(h) Medium tree, LC 654, insert along the right spine, good trick, new, fb imported
1008 Construct Binary Search Tree from Preorder Traversal Python O(n) O(n), recursion depth (skewed tree) Medium tree, RECURSION + UPPER BOUND (single pass), new, amazon, fb, apple, microsoft imported
1026 Maximum Difference Between Node and Ancestor Python O(n) O(h), recursion depth Medium tree, DFS, carry the MIN and MAX seen on the path from the root, new, google, amazon, fb imported
1065 Index Pairs of a String Python O(sum(len(w)) + n * L), n = len(text), L = max word length O(sum(len(w))) Easy tree, 🔒, TRIE, new, amazon imported
1080 Insufficient Nodes in Root to Leaf Paths Python O(n) O(h), h = tree height Medium tree, DFS (post order) + pass the REMAINING limit down, new, amazon, apple imported
1104 Path In Zigzag Labelled Binary Tree Python O(log label) O(log label) Medium tree, MATH (mirror the label back to the “normal” numbering), new, amazon, fb imported
1120 Maximum Average Subtree Python O(n) O(h) h = tree height (recursion stack) Medium tree, 🔒, POST-ORDER DFS (each node returns (subtree sum, subtree size)), new, amazon, fb imported
1261 Find Elements in a Contaminated Binary Tree Python O(n) for init, O(1) for find O(n) Medium tree, DFS RECOVER + HASH SET, new, google imported
1409 Queries on a Permutation With Key Python O(m * q), q = len(queries) O(m) Medium tree, SIMULATION (m <= 1000, so a plain list is fast enough), new, amazon imported
1430 Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree Python O(n) O(h) Medium tree, 🔒, DFS, new, google, amazon imported
1469 Find All The Lonely Nodes Python O(n) O(h) recursion, h = tree height Easy tree, 🔒, DFS (a node reports its own single child, never itself), new imported
1490 Clone N-ary Tree Python O(n) O(h) recursion, h = depth Medium tree, 🔒, POST-ORDER DFS (clone the children first, then build the parent), new, google, amazon imported
1505 Minimum Possible Integer After at Most K Adjacent Swaps On Digits Python O(n * 10 * log n) O(n) Hard tree, GREEDY + BINARY INDEXED TREE (Fenwick tree), new, amazon imported
1506 Find Root of N-Ary Tree Python O(n) O(1) Medium tree, 🔒, XOR TRICK (O(1) extra space), new, google imported
1516 Move Sub-Tree of N-Ary Tree Python O(n) O(n) Hard tree, 🔒, PARENT MAP + 3-CASE SURGERY, new, google imported
1519 Number of Nodes in the Sub-Tree With the Same Label Python O(26 * n) O(26 * n) Medium tree, POST-ORDER DFS, MERGING 26-SLOT LABEL COUNTERS UPWARDS, new, uber imported
1612 Check If Two Expression Trees are Equivalent Python O(n1 + n2) O(26) counters + O(h) stack Medium tree, 🔒, COUNT LEAVES (addition is commutative + associative -> only the, new, google imported
1649 Create Sorted Array through Instructions Python O(n log M), M = max value O(M) Hard tree, BINARY INDEXED TREE (Fenwick) as a live frequency histogram, new imported
1938 Maximum Genetic Difference Query Python O((n + q) * 18) O(n * 18) Hard tree, OFFLINE DFS + BINARY TRIE THAT HOLDS EXACTLY THE CURRENT ROOT PATH, new imported
1948 Delete Duplicate Folders in System Python O(total signature length) O(same) Hard tree, TRIE + SUBTREE SERIALIZATION (canonical string per folder = its identity), new, google, amazon imported
2003 Smallest Missing Genetic Value in Each Subtree Python O(n) O(n) Hard tree, WALK UP THE PATH FROM THE NODE HOLDING VALUE 1 (incremental DFS), new imported
2096 Step-By-Step Directions From a Binary Tree Node to Another Python O(n) O(n) Medium tree, ROOT-TO-NODE PATHS + STRIP THE COMMON PREFIX (the LCA), new, google, amazon imported
2179 Count Good Triplets in an Array Python O(n log n) O(n) Hard tree, BIT (FENWICK) over positions in nums2, count “middle” elements, new imported
2196 Create Binary Tree From Descriptions Python O(n) O(n) Medium tree, NODE POOL KEYED BY VALUE + A SET OF EVERY VALUE THAT HAS A PARENT, new imported
2236 Root Equals Sum of Children Python O(1) O(1) Easy tree, DIRECT NODE ACCESS (the tree is guaranteed to have exactly 3 nodes), new imported
2277 Closest Node to Path in Tree Python O(n^2 + m * n) O(n^2) Hard tree, 🔒, n <= 1000 -> PRECOMPUTE ALL-PAIRS DISTANCES WITH n BFS RUNS, new imported
2421 Number of Good Paths Python O(n log n) O(n) Hard tree, ADD EDGES IN INCREASING “MAX ENDPOINT VALUE” ORDER (union-find), new imported
3109 Find the Index of Permutation Python O(n log n) O(n) Medium tree, 🔒, FACTORIAL NUMBER SYSTEM — COUNT THE PERMUTATIONS SKIPPED AT EACH SLOT, new imported
3515 Shortest Path in a Weighted Tree Python O((n + q) * log n) O(n) Hard tree, EULER TOUR TURNS “EDGE UPDATE” INTO A RANGE ADD ON A FENWICK TREE, new imported
3553 Minimum Weighted Subgraph With the Required Paths II Python O(n * log n + q) O(n * log n) Hard tree, THE STEINER TREE OF THREE NODES IS HALF THE SUM OF THEIR PAIRWISE PATHS, new imported
3558 Number of Ways to Assign Edge Weights I Python O(n) O(n) Medium tree, ONLY THE PARITY MATTERS, SO EXACTLY HALF THE ASSIGNMENTS WORK, new imported
3559 Number of Ways to Assign Edge Weights II Python O(n * log n + q) O(n * log n) Hard tree, PATH LENGTH VIA LCA, THEN THE PARITY COUNT IS 2^(L-1), new imported
3585 Find Weighted Median Node in Tree Python O((n + q) * log n) O(n * log n) Hard tree, ROOT DISTANCES + LCA, THEN ONE BINARY-LIFTING JUMP PER QUERY, new imported

Two Pointers

# Title Solution Time Space Difficulty Note Status
1033 Moving Stones Until Consecutive Python O(1) O(1) Medium two pointers, MATH / CASE ANALYSIS, new, fb imported
1040 Moving Stones Until Consecutive II Python O(n log n) O(1) Medium two pointers, SORT + SLIDING WINDOW (min) + MATH (max), new, fb imported
1156 Swap For Longest Repeated Character Substring Python O(n) O(1) Medium two pointers, TWO POINTERS + counting, new, amazon imported
1169 Invalid Transactions Python O(n^2) O(n) Medium two pointers, HASH TABLE (group by name) + PAIRWISE CHECK, new, amazon, apple, bloomberg imported
1176 Diet Plan Performance Python O(n) O(1) Easy two pointers, FIXED SIZE SLIDING WINDOW, new, amazon imported
1208 Get Equal Substrings Within Budget Python O(n) O(1) Medium two pointers, SLIDING WINDOW (2 pointers), new imported
1213 Intersection of Three Sorted Arrays Python O(n1 + n2 + n3) O(1), excluding the output Easy two pointers, 🔒, 3 POINTERS (k-way merge on sorted arrays), new, fb imported
1214 Two Sum BSTs Python O(m + n) O(m + n) Medium two pointers, 🔒, IN-ORDER TRAVERSAL (-> sorted array) + TWO POINTERS, new, amazon imported
1234 Replace the Substring for Balanced String Python O(n) O(1) Medium two pointers, SLIDING WINDOW / TWO POINTERS (shrinkable window), new, apple imported
1297 Maximum Number of Occurrences of a Substring Python O(n * minSize) O(n * minSize) Medium two pointers, SLIDING WINDOW of FIXED size minSize + HASH MAP, new, amazon, fb imported
1305 All Elements in Two Binary Search Trees Python O(m + n) O(m + n) Medium two pointers, INORDER + TWO POINTERS MERGE (never re-sort), new, google, amazon, fb, apple imported
1358 Number of Substrings Containing All Three Characters Python O(n) O(1) Medium two pointers, LAST-SEEN INDEX (one pass), new imported
1425 Constrained Subsequence Sum Python O(n) O(n) Hard two pointers, DP + MONOTONIC DEQUE (sliding window maximum), new, google imported
1456 Maximum Number of Vowels in a Substring of Given Length Python O(n) O(1) Medium two pointers, FIXED SIZE SLIDING WINDOW, new, amazon imported
1493 Longest Subarray of 1’s After Deleting One Element Python O(n) O(1) Medium two pointers, SLIDING WINDOW (longest window holding at most one 0), new imported
1508 Range Sum of Sorted Subarray Sums Python O(n^2 log n) O(n^2) Medium two pointers, BUILD ALL SUBARRAY SUMS + SORT, new, google imported
1521 Find a Value of a Mysterious Function Closest to Target Python O(n * log M) O(log M) Hard two pointers, SET OF DISTINCT AND-VALUES ENDING AT EACH INDEX, new imported
1604 Alert Using Same Key-Card Three or More Times in a One Hour Period Python O(n log n) O(n) Medium two pointers, GROUP BY NAME + SORT + FIXED-WIDTH WINDOW OF 3, new imported
1687 Delivering Boxes from Storage to Ports Python O(n) O(n) Hard two pointers, DP + SLIDING-WINDOW MINIMUM (monotonic deque) – O(n), not O(n * maxBoxes), new, google imported
1695 Maximum Erasure Value Python O(n) O(n) Medium two pointers, SLIDING WINDOW / TWO POINTERS (longest-unique-window, but scored by sum), new imported
1712 Ways to Split Array Into Three Subarrays Python O(n * log n) O(n) Medium two pointers, PREFIX SUM + BINARY SEARCH (nums are non-negative -> prefix is monotone), new, amazon imported
1750 Minimum Length of String After Deleting Similar Ends Python O(n) O(1) Medium two pointers, TWO POINTERS SHRINKING INWARD (greedy - always strip the full block), new, amazon imported
1852 Distinct Numbers in Each Subarray Python O(n) O(k) Medium two pointers, 🔒, FIXED-SIZE SLIDING WINDOW + COUNTER (distinct == number of live keys), new, amazon imported
1855 Maximum Distance Between a Pair of Values Python O(m + n) O(1) Medium two pointers, TWO POINTERS (both arrays are non-increasing -> j never moves back), new, google imported
1868 Product of Two Run-Length Encoded Arrays Python O(m + n) O(m + n) for the output Medium two pointers, 🔒, TWO POINTERS OVER THE RUNS (never expand the arrays), new, fb imported
1885 Count Pairs in Two Arrays Python O(n log n) O(n) Medium two pointers, 🔒, REWRITE THE INEQUALITY, THEN SORT + TWO POINTERS, new imported
1989 Maximum Number of People That Can Be Caught in Tag Python O(n) O(1) Medium two pointers, 🔒, GREEDY TWO POINTERS (match each catcher to the leftmost free target), new imported
2024 Maximize the Confusion of an Exam Python O(n) O(1) Medium two pointers, SLIDING WINDOW, TWICE (same as LC 424 “longest repeating char replacement”), new, amazon imported
2040 Kth Smallest Product of Two Sorted Arrays Python O(n log m log R) O(1) Hard two pointers, BINARY SEARCH ON THE ANSWER + O(n log m) COUNTER, new imported
2046 Sort Linked List Already Sorted Using Absolute Values Python O(n) O(1) Medium two pointers, 🔒, THE NEGATIVES ARE ALREADY IN REVERSE ORDER — MOVE THEM TO THE FRONT, new imported
2062 Count Vowel Substrings of a String Python O(n^2) O(1) (the set holds at most 5 letters) Easy two pointers, EXPAND EVERY LEFT ENDPOINT, STOP AT THE FIRST CONSONANT, new imported
2067 Number of Equal Count Substrings Python O(26 * n) O(26) Medium two pointers, 🔒, FIXED-SIZE SLIDING WINDOW, ONE PASS PER DISTINCT-LETTER COUNT, new imported
2090 K Radius Subarray Averages Python O(n) O(n) Medium two pointers, PREFIX SUM (fixed-width window of size 2k+1), new imported
2105 Watering Plants II Python O(n) O(1) Medium two pointers, STRAIGHT TWO-POINTER SIMULATION FROM BOTH ENDS, new, google imported
2107 Number of Unique Flavors After Sharing K Candies Python O(n) O(n) Medium two pointers, 🔒, FIXED-SIZE SLIDING WINDOW OF THE REMOVED CANDIES, new imported
2134 Minimum Swaps to Group All 1’s Together II Python O(n) O(1) Medium two pointers, FIXED-WIDTH CIRCULAR SLIDING WINDOW — MINIMIZE THE ZEROS INSIDE, new imported
2149 Rearrange Array Elements by Sign Python O(n) O(n) for the output Medium two pointers, TWO WRITE POINTERS — EVEN SLOTS FOR POSITIVES, ODD FOR NEGATIVES, new, amazon imported
2161 Partition Array According to Given Pivot Python O(n) O(n) Medium two pointers, STABLE THREE-WAY SPLIT IN ONE PASS, new, amazon imported
2200 Find All K-Distant Indices in an Array Python O(n * k) O(n) Easy two pointers, PAINT AN INTERVAL AROUND EVERY key OCCURRENCE, new imported
2234 Maximum Total Beauty of the Gardens Python O(n log n) O(n) Hard two pointers, SORT + ENUMERATE HOW MANY GARDENS END UP COMPLETE + BINARY SEARCH, new imported
2302 Count Subarrays With Score Less Than K Python O(n) O(1) Hard two pointers, SLIDING WINDOW (score is monotonic when the window grows), new imported
2330 Valid Palindrome IV Python O(n) O(1) Medium two pointers, 🔒, COUNT THE MISMATCHED MIRROR PAIRS — THE ANSWER IS “AT MOST 2”, new imported
2332 The Latest Time to Catch a Bus Python O(n log n + m log m) O(m) Medium two pointers, SIMULATE THE BOARDING, THEN WALK BACK FROM THE BEST SEAT, new imported
2337 Move Pieces to Obtain a String Python O(n) O(n) Medium two pointers, PIECES CANNOT PASS EACH OTHER — COMPARE THEM IN ORDER, POSITION BY POSITION, new imported
2379 Minimum Recolors to Get K Consecutive Black Blocks Python O(n) O(1) Easy two pointers, FIXED-WIDTH SLIDING WINDOW — MINIMISE THE WHITES INSIDE, new imported
2393 Count Strictly Increasing Subarrays Python O(n) O(1) Medium two pointers, 🔒, SPLIT INTO MAXIMAL INCREASING RUNS AND COUNT EACH ONE’S SUBARRAYS, new imported
2401 Longest Nice Subarray Python O(n) O(1) Medium two pointers, “ALL PAIRWISE ANDs ARE 0” == “NO TWO ELEMENTS SHARE A SET BIT”, new imported
2444 Count Subarrays With Fixed Bounds Python O(n) O(1) Hard two pointers, THREE POINTERS (last bad index + last minK index + last maxK index), new imported
2465 Number of Distinct Averages Python O(n log n) O(n) Easy two pointers, SORT, THEN PAIR THE ENDS INWARD, new imported
2511 Maximum Enemy Forts That Can Be Captured Python O(n) O(1) Easy two pointers, TWO POINTERS (scan between consecutive non-zero forts), new imported
2516 Take K of Each Character From Left and Right Python O(n) O(1) Medium two pointers, SLIDING WINDOW ON THE COMPLEMENT (two pointers), new imported
2524 Maximum Frequency Score of a Subarray Python O(n * log(max(nums))) O(n) (log factor = modular pow) Hard two pointers, 🔒, SLIDING WINDOW + COUNTER + INCREMENTAL MODULAR UPDATE, new imported
2537 Count the Number of Good Subarrays Python O(n) O(n) Medium two pointers, SLIDING WINDOW (TWO POINTERS) + HASH COUNTER, new imported
2540 Minimum Common Value Python O(m + n) O(1) Easy two pointers, TWO POINTERS (merge-style walk over two sorted arrays), new imported
2563 Count the Number of Fair Pairs Python O(n log n) O(1) beyond the sort Medium two pointers, SORTING + TWO POINTERS (count(<= x) via a shrinking window), new imported
2570 Merge Two 2D Arrays by Summing Values Python O(n + m) O(1) beyond the output Easy two pointers, TWO POINTERS (classic merge step of merge-sort), new imported
2609 Find the Longest Balanced Substring of a Binary String Python O(n) O(1) Easy two pointers, RUN-LENGTH COUNTERS (two pointers over the 0-run / 1-run boundary), new imported
2653 Sliding Subarray Beauty Python O(n * 50) O(1) (the table has a fixed size of 50) Medium two pointers, SLIDING WINDOW + COUNTING SORT (values are bounded by [-50, 50]), new imported
2730 Find the Longest Semi-Repetitive Substring Python O(n) O(1) Medium two pointers, TWO POINTERS / SLIDING WINDOW ON ADJACENT-EQUAL PAIRS, new imported
2743 Count Substrings Without Repeating Character Python O(n) O© with C = 26 Medium two pointers, 🔒, SLIDING WINDOW (TWO POINTERS) + “COUNT SUBSTRINGS ENDING AT i”, new imported
2747 Count Zero Request Servers Python O(LlogL + MlogM + n) O(L + M) (L = len(logs), M = len(queries)) Medium two pointers, OFFLINE QUERIES + SORTING + SLIDING WINDOW (two pointers), new imported
2762 Continuous Subarrays Python O(n) O(n) Medium two pointers, SLIDING WINDOW + TWO MONOTONIC DEQUES (window max & window min), new imported
2763 Sum of Imbalance Numbers of All Subarrays Python O(n^2) O(n) Hard two pointers, GROW THE RIGHT END + REWRITE IMBALANCE AS A COUNT OVER THE VALUE SET, new imported
2779 Maximum Beauty of an Array After Applying Operation Python O(n log n) O(n) for the sort Medium two pointers, SORT + SLIDING WINDOW OF WIDTH 2k, new imported
2781 Length of the Longest Valid Substring Python O(n * L^2) with L = 10 (substring slicing) O(total forbidden chars) Hard two pointers, SLIDING WINDOW + BOUNDED SUFFIX LOOKUP, new imported
2799 Count Complete Subarrays in an Array Python O(n) O(n) Medium two pointers, SLIDING WINDOW (TWO POINTERS) + COUNTER, new imported
2824 Count Pairs Whose Sum is Less than Target Python O(n * log n) O(n) # O(1) extra if sorting in place Easy two pointers, SORT + TWO POINTERS, new imported
2831 Find the Longest Equal Subarray Python O(n) O(n) Medium two pointers, TWO POINTERS OVER THE INDEX LIST OF EACH VALUE, new imported
2838 Maximum Coins Heroes Can Collect Python O(n log n + m log m) O(n + m) Medium two pointers, 🔒, SORT + PREFIX SUM + TWO POINTERS, new imported
2841 Maximum Sum of Almost Unique Subarray Python O(n) O(k) Medium two pointers, FIXED-SIZE SLIDING WINDOW + HASH TABLE (running sum & distinct count), new imported
2904 Shortest and Lexicographically Smallest Beautiful String Python O(n^2) (slicing the window is O(n) per step) O(n) Medium two pointers, TWO POINTERS (SLIDING WINDOW PINNED TO ‘1’ BOUNDARIES), new imported
3006 Find Beautiful Indices in the Given Array I Python O(n * m + n log n) O(n) Medium two pointers, COLLECT BOTH OCCURRENCE LISTS, THEN BINARY SEARCH THE WINDOW, new imported
3008 Find Beautiful Indices in the Given Array II Python O(|s| + |a| + |b|) O(|s| + |a| + |b|) Hard two pointers, KMP FOR BOTH PATTERNS, THEN A SINGLE MERGE PASS, new imported
3013 Divide an Array Into Subarrays With Minimum Cost II Python O(n log n) O(n) Hard two pointers, SLIDING WINDOW OF WIDTH dist+1, KEEPING THE k-1 SMALLEST STARTS, new imported
3085 Minimum Deletions to Make String K-Special Python O(n + 26^2) O(1) Medium two pointers, FIX THE SURVIVING MINIMUM FREQUENCY AND CHARGE EVERY LETTER, new imported
3095 Shortest Subarray With OR at Least K I Python O(n^2) O(1) Easy two pointers, n <= 50 — GROW EVERY SUBARRAY AND STOP AS SOON AS THE OR CLEARS k, new imported
3097 Shortest Subarray With OR at Least K II Python O(30 * n) O(1) Medium two pointers, SLIDING WINDOW WITH A COUNTER PER BIT (OR IS NOT INVERTIBLE), new imported
3171 Find Subarray With Bitwise OR Closest to K Python O(30 * n) O(30) Hard two pointers, THE ORs OF ALL SUBARRAYS ENDING AT i FORM AT MOST ~30 DISTINCT VALUES, new imported
3206 Alternating Groups I Python O(n) O(1) Easy two pointers, CHECK EVERY WINDOW OF THREE, WRAPPING WITH MODULO, new imported
3208 Alternating Groups II Python O(n + k) O(1) Medium two pointers, TRACK THE CURRENT ALTERNATING RUN LENGTH AROUND THE CIRCLE, new imported
3234 Count the Number of Substrings With Dominant Ones Python O(n * sqrt(n)) O(n) Medium two pointers, THE ZERO COUNT IS BOUNDED BY sqrt(n) — ENUMERATE IT, new imported
3254 Find the Power of K-Size Subarrays I Python O(n * k) O(n) Medium two pointers, “CONSECUTIVE AND ASCENDING” JUST MEANS EVERY STEP IS EXACTLY +1, new imported
3255 Find the Power of K-Size Subarrays II Python O(n) O(n) for the output Medium two pointers, ONE RUNNING STREAK OF “+1 STEPS” ANSWERS EVERY WINDOW, new imported
3258 Count Substrings That Satisfy K-Constraint I Python O(n) O(1) Easy two pointers, SLIDING WINDOW — THE CONSTRAINT IS MONOTONE IN THE WINDOW SIZE, new imported
3261 Count Substrings That Satisfy K-Constraint II Python O(n + q log n) O(n) Hard two pointers, PRECOMPUTE THE SHORTEST VALID LEFT END PER RIGHT END, THEN PREFIX SUM, new imported
3264 Final Array State After K Multiplication Operations I Python O((n + k) log n) O(n) Easy two pointers, MIN-HEAP KEYED BY (VALUE, INDEX) — THE TIE-BREAK IS THE INDEX, new imported
3266 Final Array State After K Multiplication Operations II Python O(n log(max) * log n + n log n) O(n) Hard two pointers, SIMULATE UNTIL THE VALUES LEVEL OFF, THEN FINISH IN BULK, new imported
3297 Count Substrings That Can Be Rearranged to Contain a String I Python O(n + m) O(1) (26 counters) Medium two pointers, “REARRANGEABLE TO HAVE word2 AS A PREFIX” == COVERS ITS LETTER COUNTS, new imported
3298 Count Substrings That Can Be Rearranged to Contain a String II Python O(n + m) O(1) (26 counters) Hard two pointers, SAME SLIDING WINDOW AS LC 3297 — IT WAS ALREADY LINEAR, new imported
3305 Count of Substrings Containing Every Vowel and K Consonants I Python O(n) O(1) Medium two pointers, “EXACTLY k” = “AT LEAST k” MINUS “AT LEAST k+1”, new imported
3306 Count of Substrings Containing Every Vowel and K Consonants II Python O(n) O(1) Medium two pointers, SAME “AT LEAST k MINUS AT LEAST k+1” TRICK, AT 2*10^5 SCALE, new imported
3318 Find X-Sum of All K-Long Subarrays I Python O(n * k log k) O(k) Easy two pointers, n <= 50 — RECOUNT EACH WINDOW AND RANK BY (COUNT, VALUE), new imported
3321 Find X-Sum of All K-Long Subarrays II Python O(n log n) O(n) Hard two pointers, TWO HEAPS STRADDLING THE “TOP x” CUT, WITH LAZY DELETION, new imported
3325 Count Substrings With K-Frequency Characters I Python O(n) O(1) (26 counters) Medium two pointers, SLIDING WINDOW — “SOME CHARACTER HITS k” ONLY GETS EASIER AS THE WINDOW GROWS, new imported
3346 Maximum Frequency of an Element After Performing Operations I Python O(n log n) O(n) Medium two pointers, FIX THE TARGET VALUE — THEN IT IS “ALREADY THERE” PLUS “CAN BE NUDGED”, new imported
3347 Maximum Frequency of an Element After Performing Operations II Python O(n log n) O(n) Hard two pointers, SAME CANDIDATE ARGUMENT AS LC 3346 — THE VALUES JUST GET BIGGER, new imported
3364 Minimum Positive Sum Subarray Python O(n^2) O(1) Easy two pointers, n <= 100 — ENUMERATE EVERY SUBARRAY IN THE LENGTH RANGE, new imported
3413 Maximum Coins From K Consecutive Bags Python O(n log n) O(n) Medium two pointers, THE BEST WINDOW ALWAYS TOUCHES A SEGMENT EDGE — SLIDE TWICE, new imported
3420 Count Non-Decreasing Subarrays After K Operations Python O(n) O(n) Hard two pointers, SLIDING WINDOW OVER A RUNNING-MAXIMUM STAIRCASE, new imported
3422 Minimum Operations to Make Subarray Elements Equal Python O(n log n) O(n) Medium two pointers, 🔒, SLIDING WINDOW MEDIAN VIA TWO FENWICK TREES, new imported
3425 Longest Special Path Python O(n) O(n) Hard two pointers, DFS CARRYING A SLIDING WINDOW ALONG THE ROOT PATH, new imported
3430 Maximum and Minimum Sums of at Most Size K Subarrays Python O(n) O(n) Hard two pointers, CONTRIBUTION BY MONOTONIC STACK, WITH A LATTICE-COUNT FOR THE LENGTH CAP, new imported
3439 Reschedule Meetings for Maximum Free Time I Python O(n) O(n) Medium two pointers, THE MEETINGS ARE JUST SPACERS — SLIDE A WINDOW OVER THE GAPS, new imported
3445 Maximum Difference Between Even and Odd Frequency II Python O(20 * n) O(n) Hard two pointers, PREFIX COUNTS + PARITY BUCKETS, WITH A SECOND POINTER FOR “NON-ZERO”, new imported
3555 Smallest Subarray to Sort in Every Sliding Window Python O(n * k) O(k) Medium two pointers, 🔒, PER WINDOW, PEEL OFF THE ALREADY-SETTLED PREFIX AND SUFFIX, new imported
3567 Minimum Absolute Difference in Sliding Submatrix Python O(m * n * k^2 * log(k^2)) O(k^2) Medium two pointers, BRUTE FORCE PER WINDOW + SORT THE DISTINCT VALUES, new imported
3584 Maximum Product of First and Last Elements of a Subsequence Python O(n) O(1) Medium two pointers, ONLY THE TWO ENDPOINTS MATTER, SO SLIDE A GAP OF m-1, new imported
3589 Count Prime-Gap Balanced Subarrays Python O(n log log max + n) O(max) Medium two pointers, TWO OPPOSING BOUNDS ON THE LEFT ENDPOINT, FOR EACH RIGHT ENDPOINT, new imported
3634 Minimum Removals to Balance Array Python O(n log n) O(1) beyond the sort Medium two pointers, SORT + SLIDING WINDOW (KEEP THE LONGEST BALANCED WINDOW), new imported
3640 Trionic Array II Python O(n) O(1) Hard two pointers, LINEAR DP OVER THE THREE PHASES (UP -> DOWN -> UP), new imported
3641 Longest Semi-Repeating Subarray Python O(n) O(n) Medium two pointers, 🔒, SLIDING WINDOW ON THE NUMBER OF DISTINCT VALUES THAT REPEAT, new imported
3649 Number of Perfect Pairs Python O(n log n) O(n) Medium two pointers, SIGNS CANCEL — THE CONDITION IS JUST max|.| <= 2 * min|.|, new imported
3652 Best Time to Buy and Sell Stock using Strategy Python O(n) O(n) Medium two pointers, PREFIX SUMS OF strategy*prices AND OF prices, new imported
3672 Sum of Weighted Modes in Subarrays Python O(n log n) O(n) Medium two pointers, 🔒, SLIDING WINDOW + BUCKETS-BY-FREQUENCY WITH LAZY HEAPS, new imported
3679 Minimum Discards to Balance Inventory Python O(n) O(n) Medium two pointers, THE RULE IS FORCED, SO SIMULATE A SLIDING WINDOW OF KEPT ITEMS, new imported