LeetCode 925: Long Pressed Name
A clear explanation of the Long Pressed Name problem using a two-pointer scan.
Tag
Algorithms
970 notes
LeetCode 975: Odd Even Jump
A clear explanation of counting good starting indices using next-jump preprocessing and dynamic programming.
LeetCode 974: Subarray Sums Divisible by K
A clear explanation of counting subarrays whose sum is divisible by k using prefix sums and remainder frequencies.
LeetCode 973: K Closest Points to Origin
A clear explanation of returning the k closest points to the origin using squared distance and sorting.
LeetCode 972: Equal Rational Numbers
A clear explanation of comparing rational numbers written as decimal strings with optional repeating parts.
LeetCode 971: Flip Binary Tree To Match Preorder Traversal
A clear explanation of matching a binary tree preorder traversal by greedily flipping nodes.
LeetCode 970: Powerful Integers
A clear explanation of generating all powerful integers using bounded powers and a set.
LeetCode 969: Pancake Sorting
A clear explanation of sorting an array using prefix reversals by repeatedly placing the largest remaining value.
LeetCode 968: Binary Tree Cameras
A clear explanation of placing the minimum number of cameras in a binary tree using postorder DFS.
LeetCode 967: Numbers With Same Consecutive Differences
A clear explanation of generating all n-digit numbers whose adjacent digits differ by k.
LeetCode 966: Vowel Spellchecker
A clear explanation of implementing a spellchecker with exact, case-insensitive, and vowel-error matching.
LeetCode 965: Univalued Binary Tree
A clear explanation of checking whether every node in a binary tree has the same value.
LeetCode 964: Least Operators to Express Number
A clear explanation of expressing a target using the fewest operators with repeated uses of x.
LeetCode 963: Minimum Area Rectangle II
A clear explanation of finding the minimum-area rectangle from points when the rectangle may be rotated.
LeetCode 962: Maximum Width Ramp
A clear explanation of finding the maximum width ramp using a monotonic decreasing stack.
LeetCode 961: N-Repeated Element in Size 2N Array
A clear explanation of finding the element repeated N times using a hash set.
LeetCode 960: Delete Columns to Make Sorted III
A clear explanation of deleting the minimum number of columns so every remaining row is individually sorted.
LeetCode 959: Regions Cut By Slashes
A clear explanation of counting regions formed by slashes using union find over four triangles per cell.
LeetCode 958: Check Completeness of a Binary Tree
A clear explanation of checking whether a binary tree is complete using level-order traversal.
LeetCode 957: Prison Cells After N Days
A clear explanation of simulating prison cell transitions efficiently using cycle detection.
LeetCode 956: Tallest Billboard
A clear explanation of solving Tallest Billboard using dynamic programming over height differences.
LeetCode 955: Delete Columns to Make Sorted II
A clear explanation of deleting the minimum number of columns so rows become lexicographically sorted.
LeetCode 954: Array of Doubled Pairs
A clear explanation of checking whether an array can be reordered into pairs where one number is double the other.
LeetCode 953: Verifying an Alien Dictionary
A clear explanation of checking whether words are sorted according to a custom alien alphabet order.
LeetCode 952: Largest Component Size by Common Factor
A clear explanation of solving Largest Component Size by Common Factor using prime factorization and union find.
LeetCode 951: Flip Equivalent Binary Trees
A clear explanation of checking whether two binary trees are equivalent after swapping left and right children at any number of nodes.
LeetCode 850: Rectangle Area II
A clear explanation of the Rectangle Area II problem using sweep line and merged active y-intervals.
LeetCode 849: Maximize Distance to Closest Person
A clear explanation of the Maximize Distance to Closest Person problem using gaps between occupied seats.
LeetCode 848: Shifting Letters
A clear explanation of the Shifting Letters problem using suffix sums and modulo arithmetic.
LeetCode 847: Shortest Path Visiting All Nodes
A clear explanation of the Shortest Path Visiting All Nodes problem using multi-source BFS and bitmask state compression.
LeetCode 846: Hand of Straights
A clear explanation of the Hand of Straights problem using sorting, frequency counting, and greedy grouping.
LeetCode 845: Longest Mountain in Array
A clear explanation of the Longest Mountain in Array problem using peak detection and two-pointer expansion.
LeetCode 844: Backspace String Compare
A clear explanation of the Backspace String Compare problem using stack simulation and an O(1) space two-pointer scan.
LeetCode 843: Guess the Word
A clear explanation of the Guess the Word interactive problem using candidate filtering and minimax-style guessing.
LeetCode 842: Split Array into Fibonacci Sequence
A clear explanation of the Split Array into Fibonacci Sequence problem using backtracking, leading-zero checks, and 32-bit integer limits.
LeetCode 841: Keys and Rooms
A clear explanation of the Keys and Rooms problem using graph traversal from room 0.
LeetCode 840: Magic Squares In Grid
A clear explanation of the Magic Squares In Grid problem using fixed-size subgrid validation.
LeetCode 839: Similar String Groups
A clear explanation of the Similar String Groups problem using graph connectivity and union-find.
LeetCode 838: Push Dominoes
A clear explanation of the Push Dominoes problem using force propagation and a two-pass scan.
LeetCode 837: New 21 Game
A clear explanation of the New 21 Game problem using probability dynamic programming and a sliding window sum.
LeetCode 836: Rectangle Overlap
A clear explanation of the Rectangle Overlap problem using axis projections and positive intersection area.
LeetCode 835: Image Overlap
A clear explanation of the Image Overlap problem using translation vectors and frequency counting.
LeetCode 834: Sum of Distances in Tree
A clear explanation of the Sum of Distances in Tree problem using tree DP, subtree sizes, and rerooting.
LeetCode 833: Find And Replace in String
A clear explanation of the Find And Replace in String problem using simultaneous replacement, source matching, and a replacement map.
LeetCode 832: Flipping an Image
A clear explanation of the Flipping an Image problem using row reversal, bit inversion, and an in-place two-pointer method.
LeetCode 831: Masking Personal Information
A clear explanation of the Masking Personal Information problem using string parsing and format-specific masking rules.
LeetCode 830: Positions of Large Groups
A clear explanation of the Positions of Large Groups problem using a simple two-pointer scan.
LeetCode 829: Consecutive Numbers Sum
A clear explanation of the Consecutive Numbers Sum problem using arithmetic series formulas and divisibility analysis.
LeetCode 828: Count Unique Characters of All Substrings of a Given String
A clear explanation of Count Unique Characters of All Substrings using contribution counting with previous and next occurrences.
LeetCode 827: Making A Large Island
A clear explanation of the Making A Large Island problem using connected component labeling and island size lookup.
LeetCode 826: Most Profit Assigning Work
A clear explanation of the Most Profit Assigning Work problem using sorting, greedy choice, and two pointers.
LeetCode 924: Minimize Malware Spread
A clear explanation of minimizing malware spread by analyzing connected components with Union Find.
LeetCode 923: 3Sum With Multiplicity
A clear explanation of counting index triplets with duplicate values using frequency counts and combinatorics.
LeetCode 922: Sort Array By Parity II
A clear explanation of placing even numbers at even indices and odd numbers at odd indices using two pointers.
LeetCode 921: Minimum Add to Make Parentheses Valid
A clear explanation of making a parentheses string valid using greedy counting.
LeetCode 920: Number of Music Playlists
A clear explanation of counting valid music playlists using dynamic programming over playlist length and unique songs used.
LeetCode 919: Complete Binary Tree Inserter
A clear explanation of maintaining a complete binary tree inserter using level-order indexing.
LeetCode 918: Maximum Sum Circular Subarray
A clear explanation of finding the maximum circular subarray sum using Kadane's algorithm.
LeetCode 917: Reverse Only Letters
A clear explanation of reversing only English letters while keeping all non-letter characters fixed.
LeetCode 916: Word Subsets
A clear explanation of finding universal words by merging character frequency requirements from words2.
LeetCode 915: Partition Array into Disjoint Intervals
A clear explanation of finding the smallest left partition using prefix maximums and suffix minimums.
LeetCode 914: X of a Kind in a Deck of Cards
A clear explanation of checking whether card counts share a common group size using the greatest common divisor.
LeetCode 913: Cat and Mouse
A clear explanation of Cat and Mouse using game states, reverse BFS, and topological propagation.
LeetCode 912: Sort an Array
A clear explanation of sorting an array without built-in sorting using merge sort.
LeetCode 911: Online Election
A clear explanation of Online Election using preprocessing and binary search over vote times.
LeetCode 910: Smallest Range II
A clear explanation of minimizing the array range after adding either +k or -k to every element.
LeetCode 909: Snakes and Ladders
A clear explanation of Snakes and Ladders using breadth-first search over board squares.
LeetCode 908: Smallest Range I
A clear explanation of minimizing an array score after each value can move by at most k.
LeetCode 907: Sum of Subarray Minimums
A clear explanation of summing subarray minimums using a monotonic stack and contribution counting.
LeetCode 906: Super Palindromes
A clear explanation of counting super-palindromes by generating palindromic roots and checking their squares.
LeetCode 905: Sort Array By Parity
A clear explanation of sorting an array by parity using a two-pointer partition method.
LeetCode 904: Fruit Into Baskets
A clear explanation of Fruit Into Baskets using a sliding window with at most two distinct fruit types.
LeetCode 903: Valid Permutations for DI Sequence
A clear explanation of counting valid DI permutations using dynamic programming and prefix sums.
LeetCode 902: Numbers At Most N Given Digit Set
A clear explanation of counting numbers less than or equal to N using digit-by-digit construction and combinatorics.
LeetCode 901: Online Stock Span
A clear explanation of Online Stock Span using a monotonic decreasing stack with accumulated spans.
LeetCode 900: RLE Iterator
A clear explanation of designing an iterator over a run-length encoded sequence without expanding it.
LeetCode 899: Orderly Queue
A clear explanation of finding the lexicographically smallest string after queue operations using rotation and sorting.
LeetCode 898: Bitwise ORs of Subarrays
A clear explanation of counting distinct bitwise OR results from all non-empty subarrays using rolling sets.
LeetCode 897: Increasing Order Search Tree
A clear explanation of rearranging a binary search tree into an increasing right-only tree using inorder traversal.
LeetCode 896: Monotonic Array
A clear explanation of checking whether an array is monotonic using one pass and direction flags.
LeetCode 895: Maximum Frequency Stack
A clear explanation of designing a stack that pops the most frequent value, breaking ties by most recent insertion.
LeetCode 894: All Possible Full Binary Trees
A clear explanation of generating all full binary trees with n nodes using recursion and memoization.
LeetCode 893: Groups of Special-Equivalent Strings
A clear explanation of counting special-equivalent string groups by building canonical signatures from even and odd positions.
LeetCode 892: Surface Area of 3D Shapes
A clear explanation of computing the exposed surface area of stacked cubes by adding tower area and subtracting shared faces.
LeetCode 891: Sum of Subsequence Widths
A clear explanation of summing subsequence widths by sorting and counting each element as a maximum and minimum.
LeetCode 890: Find and Replace Pattern
A clear explanation of finding words that match a pattern using bijective character mapping.
LeetCode 889: Construct Binary Tree from Preorder and Postorder Traversal
A clear explanation of reconstructing a binary tree from preorder and postorder traversals using recursion and index ranges.
LeetCode 888: Fair Candy Swap
A clear explanation of finding one candy box swap that makes Alice and Bob have equal total candies.
LeetCode 887: Super Egg Drop
A clear explanation of finding the minimum worst-case number of moves using dynamic programming over eggs and moves.
LeetCode 886: Possible Bipartition
A clear explanation of checking whether people can be split into two groups using graph coloring and bipartite graph detection.
LeetCode 885: Spiral Matrix III
A clear explanation of generating grid coordinates in an outward clockwise spiral using simulation.
LeetCode 884: Uncommon Words from Two Sentences
A clear explanation of finding uncommon words by counting word frequencies across both sentences.
LeetCode 883: Projection Area of 3D Shapes
A clear explanation of computing the projection areas of stacked cubes from top, front, and side views.
LeetCode 882: Reachable Nodes In Subdivided Graph
A clear explanation of counting reachable original and subdivided nodes using Dijkstra's shortest path algorithm.
LeetCode 881: Boats to Save People
A clear explanation of minimizing rescue boats using sorting, greedy choice, and two pointers.
LeetCode 880: Decoded String at Index
A clear explanation of finding the kth character in a decoded string without building the full decoded string.
LeetCode 879: Profitable Schemes
A clear explanation of counting profitable crime schemes using 0/1 knapsack dynamic programming with members and profit states.
LeetCode 878: Nth Magical Number
A clear explanation of finding the nth magical number using binary search, greatest common divisor, least common multiple, and inclusion-exclusion.
LeetCode 877: Stone Game
A clear explanation of the Stone Game problem using game theory and interval dynamic programming.
LeetCode 876: Middle of the Linked List
A clear explanation of finding the middle node of a singly linked list using slow and fast pointers.
LeetCode 625: Minimum Factorization
A clear explanation of Minimum Factorization using greedy digit factors from 9 down to 2.
LeetCode 624: Maximum Distance in Arrays
A clear explanation of Maximum Distance in Arrays using sorted endpoints and a greedy scan.
LeetCode 623: Add One Row to Tree
A clear explanation of Add One Row to Tree using tree traversal and careful subtree reconnection.
LeetCode 622: Design Circular Queue
A clear explanation of Design Circular Queue using a fixed array, a front pointer, and a size counter.
LeetCode 621: Task Scheduler
A clear explanation of Task Scheduler using frequency counting and the greedy block formula.
LeetCode 250: Count Univalue Subtrees
A clear explanation of counting uni-value subtrees using post-order DFS.
LeetCode 249: Group Shifted Strings
A clear explanation of grouping strings by their shifting sequence using normalized hash keys.
LeetCode 248: Strobogrammatic Number III
A clear explanation of counting strobogrammatic numbers in a string range using recursive generation and range filtering.
LeetCode 247: Strobogrammatic Number II
A clear explanation of generating all strobogrammatic numbers of length n using recursion from the inside out.
LeetCode 246: Strobogrammatic Number
A clear explanation of the Strobogrammatic Number problem using digit rotation rules and two pointers.
LeetCode 245: Shortest Word Distance III
A clear explanation of the Shortest Word Distance III problem, including the special case where both target words are the same.
LeetCode 244: Shortest Word Distance II
A clear explanation of the Shortest Word Distance II problem using preprocessing and two pointers.
LeetCode 243: Shortest Word Distance
A clear explanation of the Shortest Word Distance problem using one pass and the latest seen indices of both words.
LeetCode 1000: Minimum Cost to Merge Stones
A clear explanation of merging consecutive stone piles with minimum cost using interval dynamic programming.
LeetCode 999: Available Captures for Rook
A clear explanation of counting how many pawns a rook can capture by scanning four directions on a chessboard.
LeetCode 998: Maximum Binary Tree II
A clear explanation of inserting a value into a maximum binary tree by following the right spine.
LeetCode 997: Find the Town Judge
A clear explanation of identifying the town judge using trust indegree and outdegree counts.
LeetCode 996: Number of Squareful Arrays
A clear explanation of counting unique permutations where every adjacent pair sums to a perfect square using backtracking.
LeetCode 995: Minimum Number of K Consecutive Bit Flips
A clear explanation of making all bits equal to 1 using greedy left-to-right flips and a sliding window flip parity.
LeetCode 994: Rotting Oranges
A clear explanation of finding the minimum time for all oranges to rot using multi-source BFS.
LeetCode 993: Cousins in Binary Tree
A clear explanation of checking whether two binary tree nodes are cousins using BFS with parent tracking.
LeetCode 992: Subarrays with K Different Integers
A clear explanation of counting subarrays with exactly k distinct integers using the at-most-k sliding window trick.
LeetCode 991: Broken Calculator
A clear explanation of finding the minimum operations by working backward from target to startValue.
LeetCode 990: Satisfiability of Equality Equations
A clear explanation of checking equality and inequality constraints using union-find.
LeetCode 989: Add to Array-Form of Integer
A clear explanation of adding an integer to an array-form number using digit-by-digit simulation.
LeetCode 988: Smallest String Starting From Leaf
A clear explanation of finding the lexicographically smallest leaf-to-root string in a binary tree using DFS.
LeetCode 987: Vertical Order Traversal of a Binary Tree
A clear explanation of vertical tree traversal using coordinates, DFS, sorting, and column grouping.
LeetCode 986: Interval List Intersections
A clear explanation of finding intersections between two sorted disjoint interval lists using two pointers.
LeetCode 985: Sum of Even Numbers After Queries
A clear explanation of maintaining the sum of even numbers after each array update.
LeetCode 984: String Without AAA or BBB
A clear explanation of constructing a string with exact counts of a and b while avoiding three equal consecutive characters.
LeetCode 983: Minimum Cost For Tickets
A clear explanation of finding the cheapest way to cover all travel days using dynamic programming.
LeetCode 982: Triples with Bitwise AND Equal To Zero
A clear explanation of counting ordered triples whose bitwise AND is zero using pairwise AND counts.
LeetCode 981: Time Based Key-Value Store
A clear explanation of designing a time-based key-value store using a hash map and binary search.
LeetCode 980: Unique Paths III
A clear explanation of counting all paths from start to end that visit every non-obstacle square exactly once using backtracking.
LeetCode 979: Distribute Coins in Binary Tree
A clear explanation of balancing coins in a binary tree using postorder DFS and subtree coin balance.
LeetCode 978: Longest Turbulent Subarray
A clear explanation of finding the longest subarray whose adjacent comparisons alternate between greater-than and less-than.
LeetCode 977: Squares of a Sorted Array
A clear explanation of sorting squared values from a sorted array using two pointers.
LeetCode 976: Largest Perimeter Triangle
A clear explanation of finding the largest valid triangle perimeter using sorting and a greedy scan.
LeetCode 875: Koko Eating Bananas
A clear explanation of finding the minimum banana-eating speed using binary search on the answer.
LeetCode 874: Walking Robot Simulation
A clear explanation of simulating robot movement on an infinite grid using direction vectors and obstacle lookup.
LeetCode 873: Length of Longest Fibonacci Subsequence
A clear explanation of finding the longest Fibonacci-like subsequence using dynamic programming and value-to-index lookup.
LeetCode 872: Leaf-Similar Trees
A clear explanation of comparing two binary trees by collecting their leaf value sequences with DFS.
LeetCode 871: Minimum Number of Refueling Stops
A clear explanation of minimizing refueling stops using a greedy max heap over reachable stations.
LeetCode 870: Advantage Shuffle
A clear explanation of maximizing the advantage of one array over another using sorting, greedy matching, and two pointers.
LeetCode 869: Reordered Power of 2
A clear explanation of checking whether the digits of a number can be reordered to form a power of two using digit frequency signatures.
LeetCode 868: Binary Gap
A clear explanation of finding the maximum distance between adjacent set bits in a binary representation.
LeetCode 867: Transpose Matrix
A clear explanation of transposing a matrix by swapping row and column indices.
LeetCode 866: Prime Palindrome
A clear explanation of finding the smallest prime palindrome greater than or equal to n by generating odd-length palindromes and testing primality.
LeetCode 865: Smallest Subtree with all the Deepest Nodes
A clear explanation of finding the smallest subtree that contains all deepest nodes using bottom-up DFS.
LeetCode 864: Shortest Path to Get All Keys
A clear explanation of finding the minimum moves to collect all keys in a grid using BFS with key bitmasks.
LeetCode 863: All Nodes Distance K in Binary Tree
A clear explanation of finding all binary tree nodes at distance k from a target node by treating the tree as an undirected graph.
LeetCode 862: Shortest Subarray with Sum at Least K
A clear explanation of finding the shortest non-empty subarray with sum at least k using prefix sums and a monotonic deque.
LeetCode 861: Score After Flipping Matrix
A clear explanation of maximizing a binary matrix score using greedy row and column flips.
LeetCode 860: Lemonade Change
A clear explanation of Lemonade Change using greedy simulation and bill counting.
LeetCode 859: Buddy Strings
A clear explanation of checking whether one swap in a string can make it equal to another string.
LeetCode 858: Mirror Reflection
A clear explanation of Mirror Reflection using room unfolding, least common multiples, and parity.
LeetCode 857: Minimum Cost to Hire K Workers
A clear explanation of hiring exactly k workers with minimum total cost using wage-to-quality ratios, sorting, and a max heap.
LeetCode 856: Score of Parentheses
A clear explanation of scoring a balanced parentheses string using depth counting.
LeetCode 855: Exam Room
A clear explanation of simulating an exam room by maintaining occupied seats in sorted order.
LeetCode 854: K-Similar Strings
A clear explanation of finding the minimum number of swaps needed to transform one anagram string into another using BFS.
LeetCode 853: Car Fleet
A clear explanation of counting car fleets by sorting cars by position and tracking arrival times.
LeetCode 852: Peak Index in a Mountain Array
A clear explanation of finding the peak index in a mountain array using binary search.
LeetCode 851: Loud and Rich
A clear explanation of Loud and Rich using graph traversal, DFS, and memoization.
LeetCode 950: Reveal Cards In Increasing Order
A clear explanation of solving Reveal Cards In Increasing Order using sorting and queue simulation over indices.
LeetCode 949: Largest Time for Given Digits
A clear explanation of solving Largest Time for Given Digits by checking all permutations of four digits.
LeetCode 948: Bag of Tokens
A clear explanation of solving Bag of Tokens using sorting, greedy choices, and two pointers.
LeetCode 947: Most Stones Removed with Same Row or Column
A clear explanation of solving Most Stones Removed with Same Row or Column using connected components and union-find.
LeetCode 946: Validate Stack Sequences
A clear explanation of solving Validate Stack Sequences by simulating stack push and pop operations.
LeetCode 945: Minimum Increment to Make Array Unique
A clear explanation of solving Minimum Increment to Make Array Unique by sorting and greedily assigning the next available value.
LeetCode 944: Delete Columns to Make Sorted
A clear explanation of solving Delete Columns to Make Sorted by checking each column independently.
LeetCode 943: Find the Shortest Superstring
A clear explanation of solving Find the Shortest Superstring using pairwise overlaps and bitmask dynamic programming.
LeetCode 942: DI String Match
A clear explanation of solving DI String Match using a greedy two-pointer construction.
LeetCode 941: Valid Mountain Array
A clear explanation of solving Valid Mountain Array by walking up the increasing slope and then down the decreasing slope.
LeetCode 940: Distinct Subsequences II
A clear explanation of solving Distinct Subsequences II using dynamic programming and last occurrence tracking.
LeetCode 939: Minimum Area Rectangle
A clear explanation of solving Minimum Area Rectangle using diagonal point pairs and constant-time point lookup.
LeetCode 938: Range Sum of BST
A clear explanation of solving Range Sum of BST using DFS with binary search tree pruning.
LeetCode 937: Reorder Data in Log Files
A clear explanation of solving Reorder Data in Log Files using custom sorting and stable handling of digit logs.
LeetCode 936: Stamping The Sequence
A clear explanation of solving Stamping The Sequence using reverse simulation and BFS-style processing.
LeetCode 935: Knight Dialer
A clear explanation of solving Knight Dialer using dynamic programming over the phone keypad graph.
LeetCode 934: Shortest Bridge
A clear explanation of solving Shortest Bridge using DFS to mark one island and BFS to expand toward the other island.
LeetCode 933: Number of Recent Calls
A clear explanation of solving Number of Recent Calls using a queue as a sliding time window.
LeetCode 932: Beautiful Array
A clear explanation of solving Beautiful Array using divide and conquer with odd and even transformations.
LeetCode 931: Minimum Falling Path Sum
A clear explanation of solving Minimum Falling Path Sum using dynamic programming over matrix rows.
LeetCode 930: Binary Subarrays With Sum
A clear explanation of solving Binary Subarrays With Sum using prefix sums and a frequency map.
LeetCode 929: Unique Email Addresses
A clear explanation of solving Unique Email Addresses using string normalization and a hash set.
LeetCode 928: Minimize Malware Spread II
A clear explanation of solving Minimize Malware Spread II by removing each infected node and simulating the final malware spread.
LeetCode 927: Three Equal Parts
A clear explanation of solving Three Equal Parts by counting ones, locating the three binary patterns, and comparing them in one pass.
LeetCode 926: Flip String to Monotone Increasing
A clear explanation of solving Flip String to Monotone Increasing with a one-pass dynamic programming approach.
LeetCode 825: Friends Of Appropriate Ages
A counting solution for computing how many directed friend requests are allowed by age rules.
LeetCode 824: Goat Latin
A string simulation solution for converting each word in a sentence into Goat Latin.
LeetCode 823: Binary Trees With Factors
A dynamic programming solution for counting binary trees where every non-leaf node is the product of its children.
LeetCode 822: Card Flipping Game
A hash set solution for finding the smallest number that can be hidden from all front-facing cards.
LeetCode 821: Shortest Distance to a Character
A two-pass solution for computing the shortest distance from each index to the nearest occurrence of a target character.
LeetCode 820: Short Encoding of Words
A suffix-removal solution for finding the shortest reference string that can encode every word.
LeetCode 819: Most Common Word
A hash map and string parsing solution for finding the most frequent non-banned word in a paragraph.
LeetCode 818: Race Car
A dynamic programming solution for finding the shortest instruction sequence that drives a race car to the target position.
LeetCode 817: Linked List Components
A hash set and linked list traversal solution for counting consecutive components whose values appear in nums.
LeetCode 816: Ambiguous Coordinates
An enumeration solution for reconstructing all valid coordinate pairs after commas, spaces, and decimal points were removed.
LeetCode 815: Bus Routes
A BFS solution for finding the minimum number of buses needed to travel from a source stop to a target stop.
LeetCode 814: Binary Tree Pruning
A postorder DFS solution for removing every binary tree subtree that does not contain a 1.
LeetCode 813: Largest Sum of Averages
A dynamic programming and prefix sum solution for partitioning an array into adjacent groups with maximum total average.
LeetCode 812: Largest Triangle Area
A geometry solution for finding the largest triangle area by checking every triplet of points with the cross product formula.
LeetCode 811: Subdomain Visit Count
A hash map solution for accumulating visit counts across domains and all of their parent subdomains.
LeetCode 810: Chalkboard XOR Game
A math and bit manipulation solution for deciding whether Alice wins the XOR removal game.
LeetCode 809: Expressive Words
A two-pointer group comparison solution for counting how many words can be stretched to match a target string.
LeetCode 808: Soup Servings
A probability dynamic programming solution for computing whether soup A empties before soup B, with an early return for large input.
LeetCode 807: Max Increase to Keep City Skyline
A greedy solution for increasing building heights as much as possible while preserving every skyline view.
LeetCode 806: Number of Lines To Write String
A simple simulation solution for counting how many 100-pixel lines are needed to write a string.
LeetCode 805: Split Array With Same Average
A dynamic programming solution for deciding whether an array can be split into two non-empty groups with the same average.
LeetCode 804: Unique Morse Code Words
A set-based solution for counting how many different Morse code transformations appear among a list of words.
LeetCode 803: Bricks Falling When Hit
A reverse simulation and union-find solution for counting how many bricks fall after each hit.
LeetCode 802: Find Eventual Safe States
A graph traversal solution for finding all nodes that cannot reach a directed cycle.
LeetCode 801: Minimum Swaps To Make Sequences Increasing
A dynamic programming solution for finding the minimum number of same-index swaps needed to make two arrays strictly increasing.
LeetCode 800: Similar RGB Color
A clear explanation of finding the closest shorthand RGB color by rounding each color channel to the nearest repeated hexadecimal pair.
LeetCode 799: Champagne Tower
A clear explanation of simulating overflow in a champagne glass pyramid using dynamic programming.
LeetCode 798: Smallest Rotation with Highest Score
A clear explanation of finding the smallest rotation with maximum score using a difference array.
LeetCode 797: All Paths From Source to Target
A clear explanation of finding every path from node 0 to node n - 1 in a directed acyclic graph using DFS and backtracking.
LeetCode 796: Rotate String
A clear explanation of checking whether one string can become another by repeated left rotations.
LeetCode 795: Number of Subarrays with Bounded Maximum
A clear explanation of counting contiguous subarrays whose maximum value lies inside a given inclusive range.
LeetCode 794: Valid Tic-Tac-Toe State
A clear explanation of validating whether a Tic-Tac-Toe board can occur in a legal game.
LeetCode 793: Preimage Size of Factorial Zeroes Function
A clear explanation of finding how many integers have exactly k trailing zeroes in their factorial.
LeetCode 792: Number of Matching Subsequences
A clear explanation of counting how many words are subsequences of a string using waiting queues.
LeetCode 791: Custom Sort String
A clear explanation of rearranging a string so that selected characters follow a custom order.
LeetCode 790: Domino and Tromino Tiling
A clear explanation of counting tilings of a 2 x n board using dominoes and L-shaped trominoes with dynamic programming.
LeetCode 789: Escape The Ghosts
A clear explanation of deciding whether escape is possible by comparing Manhattan distances to the target.
LeetCode 788: Rotated Digits
A clear explanation of counting good numbers after rotating every digit by 180 degrees.
LeetCode 787: Cheapest Flights Within K Stops
A clear explanation of finding the cheapest flight route with at most k stops using bounded Bellman-Ford relaxation.
LeetCode 786: K-th Smallest Prime Fraction
A clear explanation of finding the kth smallest fraction from a sorted array using a min-heap.
LeetCode 785: Is Graph Bipartite?
A clear explanation of checking whether an undirected graph can be split into two independent sets using graph coloring.
LeetCode 784: Letter Case Permutation
A clear explanation of generating all strings formed by independently changing each letter to lowercase or uppercase.
LeetCode 783: Minimum Distance Between BST Nodes
A clear explanation of finding the minimum difference between any two nodes in a BST using inorder traversal.
LeetCode 782: Transform to Chessboard
A clear explanation of transforming a binary board into a chessboard using feasibility checks and minimum row and column swaps.
LeetCode 781: Rabbits in Forest
A clear explanation of finding the minimum possible number of rabbits using counting and greedy grouping.
LeetCode 780: Reaching Points
A clear explanation of checking whether one point can reach another by working backward with modulo.
LeetCode 779: K-th Symbol in Grammar
A clear explanation of finding the kth symbol in the grammar sequence using recursion and the parent-child relationship.
LeetCode 778: Swim in Rising Water
A clear explanation of finding the minimum time to reach the bottom-right cell using a priority queue and minimax path reasoning.
LeetCode 777: Swap Adjacent in LR String
A clear explanation of validating string transformation using two pointers and movement constraints.
LeetCode 776: Split BST
A clear explanation of splitting a binary search tree into two BSTs using recursion and pointer rewiring.
LeetCode 775: Global and Local Inversions
A clear explanation of checking whether every global inversion is also a local inversion using distance constraints.
LeetCode 774: Minimize Max Distance to Gas Station
A clear explanation of minimizing the largest adjacent gas-station distance using binary search on the answer.
LeetCode 773: Sliding Puzzle
A clear explanation of solving the 2 x 3 sliding puzzle using breadth-first search over board states.
LeetCode 772: Basic Calculator III
A clear explanation of evaluating arithmetic expressions with parentheses, precedence, and integer division.
LeetCode 771: Jewels and Stones
A clear explanation of counting how many stones are jewels using a hash set for fast membership checks.
LeetCode 770: Basic Calculator IV
A clear explanation of simplifying algebraic expressions by parsing, substituting variables, and combining polynomial terms.
LeetCode 769: Max Chunks To Make Sorted
A clear explanation of splitting a permutation into the maximum number of chunks using prefix maximums.
LeetCode 768: Max Chunks To Make Sorted II
A clear explanation of splitting an array into the maximum number of chunks so sorting each chunk gives the fully sorted array.
LeetCode 767: Reorganize String
A clear explanation of rearranging characters so no two adjacent characters are equal using a greedy max heap.
LeetCode 766: Toeplitz Matrix
A clear explanation of checking whether every top-left to bottom-right diagonal in a matrix has the same value.
LeetCode 765: Couples Holding Hands
A clear explanation of minimizing swaps so every couple sits together using greedy position tracking.
LeetCode 764: Largest Plus Sign
A clear explanation of finding the largest plus sign in a mined grid using four directional dynamic programming scans.
LeetCode 763: Partition Labels
A clear explanation of partitioning a string into the maximum number of parts so each character appears in at most one part.
LeetCode 762: Prime Number of Set Bits in Binary Representation
A clear explanation of counting numbers whose binary representation has a prime number of set bits.
LeetCode 761: Special Binary String
A clear explanation of making a special binary string lexicographically largest using recursive decomposition and sorting.
LeetCode 760: Find Anagram Mappings
A clear explanation of mapping each element in one array to a matching index in its anagram using a hash map.
LeetCode 759: Employee Free Time
A clear explanation of finding common free time by merging all employee busy intervals and returning the gaps.
LeetCode 758: Bold Words in String
A clear explanation of marking matching substrings and merging overlapping bold ranges.
LeetCode 757: Set Intersection Size At Least Two
A clear explanation of solving interval intersection constraints using greedy sorting and minimal point selection.
LeetCode 756: Pyramid Transition Matrix
A clear explanation of solving Pyramid Transition Matrix using backtracking and memoization over pyramid rows.
LeetCode 755: Pour Water
A clear explanation of simulating water droplets over an elevation map by checking left first, then right.
LeetCode 754: Reach a Number
A clear explanation of reaching a target on a number line using cumulative sums and parity.
LeetCode 753: Cracking the Safe
A clear explanation of Cracking the Safe using a de Bruijn sequence and depth-first search over password states.
LeetCode 752: Open the Lock
A clear explanation of solving Open the Lock using breadth-first search over lock states.
LeetCode 751: IP to CIDR
A clear explanation of converting a range of IPv4 addresses into the shortest list of CIDR blocks using greedy bit manipulation.
LeetCode 725: Split Linked List in Parts
A clear explanation of splitting a linked list into k consecutive parts with sizes as equal as possible.
LeetCode 724: Find Pivot Index
A clear explanation of finding the leftmost pivot index using prefix sums and a running left sum.
LeetCode 723: Candy Crush
A clear explanation of restoring a Candy Crush board to a stable state using repeated marking, crushing, and gravity simulation.
LeetCode 722: Remove Comments
A clear explanation of removing line comments and block comments from source code using a state machine.
LeetCode 721: Accounts Merge
A clear explanation of merging accounts that share emails using union find and sorted email groups.
LeetCode 720: Longest Word in Dictionary
A clear explanation of finding the longest buildable word using sorting and a hash set.
LeetCode 719: Find K-th Smallest Pair Distance
A clear explanation of finding the kth smallest pair distance using sorting, binary search on the answer, and a two-pointer count.
LeetCode 718: Maximum Length of Repeated Subarray
A clear explanation of finding the longest common contiguous subarray using dynamic programming.
LeetCode 717: 1-bit and 2-bit Characters
A clear explanation of determining whether the last character must be a one-bit character using greedy parsing.
LeetCode 716: Max Stack
A clear explanation of designing a stack that supports push, pop, top, peekMax, and popMax.
LeetCode 715: Range Module
A clear explanation of designing a range module that can add, query, and remove half-open intervals.
LeetCode 714: Best Time to Buy and Sell Stock with Transaction Fee
A clear explanation of maximizing stock trading profit with unlimited transactions and a fixed transaction fee using dynamic programming.
LeetCode 713: Subarray Product Less Than K
A clear explanation of counting contiguous subarrays whose product is less than k using a sliding window.
LeetCode 712: Minimum ASCII Delete Sum for Two Strings
A clear explanation of using dynamic programming to minimize the ASCII cost of deletions needed to make two strings equal.
LeetCode 711: Number of Distinct Islands II
A clear explanation of counting distinct island shapes under rotation and reflection using normalization and geometric transformations.
LeetCode 710: Random Pick with Blacklist
A clear explanation of selecting a uniformly random integer while excluding blacklisted values using remapping and hashing.
LeetCode 709: To Lower Case
A clear explanation of converting uppercase ASCII letters to lowercase by scanning the string once.
LeetCode 708: Insert into a Sorted Circular Linked List
A clear explanation of inserting a value into a sorted circular linked list while preserving the circular sorted order.
LeetCode 707: Design Linked List
A clear explanation of implementing a linked list from scratch using nodes, a dummy head, and a size counter.
LeetCode 706: Design HashMap
A clear explanation of designing a hash map without using built-in hash table libraries.
LeetCode 705: Design HashSet
A clear explanation of designing a hash set without using built-in hash table libraries.
LeetCode 704: Binary Search
A clear explanation of searching for a target in a sorted array using binary search.
LeetCode 703: Kth Largest Element in a Stream
A clear explanation of maintaining the kth largest element in a stream using a fixed-size min heap.
LeetCode 702: Search in a Sorted Array of Unknown Size
A clear explanation of searching in a sorted array when the array length is hidden behind an ArrayReader interface.
LeetCode 701: Insert into a Binary Search Tree
A clear explanation of inserting a value into a binary search tree using recursive and iterative traversal.
LeetCode 750: Number Of Corner Rectangles
Count axis-aligned rectangles whose four corners are 1 using column-pair frequency counting.
LeetCode 749: Contain Virus
Simulate virus containment by repeatedly quarantining the most dangerous infected region and spreading the remaining regions.
LeetCode 748: Shortest Completing Word
Find the shortest word that contains all required license plate letters using frequency counting.
LeetCode 747: Largest Number At Least Twice of Others
Find whether the maximum element is at least twice every other element using a single linear scan.
LeetCode 746: Min Cost Climbing Stairs
Find the minimum cost to reach the top of the staircase using dynamic programming.
LeetCode 745: Prefix and Suffix Search
Support fast prefix and suffix queries by indexing every prefix-suffix combination with the largest word index.
LeetCode 744: Find Smallest Letter Greater Than Target
Use binary search to find the smallest character strictly greater than the target with wraparound handling.
LeetCode 743: Network Delay Time
Find the time needed for a signal to reach all nodes in a directed weighted graph using Dijkstra's algorithm.
LeetCode 742: Closest Leaf in a Binary Tree
Find the nearest leaf to a target node by converting the tree into an undirected graph and running breadth-first search.
LeetCode 741: Cherry Pickup
Maximize cherries collected on a round trip by converting the problem into two simultaneous forward paths and solving with dynamic programming.
LeetCode 740: Delete and Earn
Transform the problem into House Robber dynamic programming by grouping equal values into total points.
LeetCode 739: Daily Temperatures
Find how many days each temperature must wait for a warmer future day using a monotonic stack.
LeetCode 738: Monotone Increasing Digits
Find the largest number less than or equal to n whose digits are monotone increasing using a greedy digit adjustment.
LeetCode 737: Sentence Similarity II
Check sentence similarity with transitive word relationships using union-find.
LeetCode 736: Parse Lisp Expression
Evaluate a Lisp-like expression with integers, variables, let bindings, addition, multiplication, and lexical scope.
LeetCode 735: Asteroid Collision
Simulate asteroid collisions using a stack that keeps the surviving asteroids in order.
LeetCode 734: Sentence Similarity
Check whether two word arrays are sentence-similar using a hash set of symmetric similar word pairs.
LeetCode 733: Flood Fill
Recolor the connected component containing the starting pixel using depth-first search.
LeetCode 732: My Calendar III
Track the maximum number of overlapping calendar events using a sweep line difference map.
LeetCode 731: My Calendar II
Allow double bookings but reject triple bookings using overlap interval tracking.
LeetCode 730: Count Different Palindromic Subsequences
Count distinct non-empty palindromic subsequences using interval dynamic programming and duplicate handling.
LeetCode 729: My Calendar I
Implement a calendar that accepts a booking only when it does not overlap with any existing booking.
LeetCode 728: Self Dividing Numbers
Check each number in a range by extracting its digits and testing whether every digit divides the original number.
LeetCode 727: Minimum Window Subsequence
Find the shortest substring of s1 that contains s2 as a subsequence using dynamic programming.
LeetCode 726: Number of Atoms
Parse a chemical formula with nested parentheses, atom names, and multipliers using recursive descent.
LeetCode 197: Rising Temperature
A clear explanation of the Rising Temperature SQL problem using a self join and date comparison.
LeetCode 196: Delete Duplicate Emails
A clear explanation of the Delete Duplicate Emails SQL problem using DELETE with a self join.
LeetCode 195: Tenth Line
A clear explanation of the Tenth Line shell problem using awk, sed, head, and tail.
LeetCode 194: Transpose File
A clear explanation of the Transpose File shell problem using awk to transform rows into columns.
LeetCode 193: Valid Phone Numbers
A clear explanation of the Valid Phone Numbers shell problem using grep and regular expressions.
LeetCode 192: Word Frequency
A clear explanation of the Word Frequency shell problem using Unix text-processing tools.
LeetCode 699: Falling Squares
Simulate falling squares on a number line and track the maximum stack height after each placement.
LeetCode 698: Partition to K Equal Sum Subsets
Decide whether an array can be divided into k non-empty subsets with equal sums using backtracking and pruning.
LeetCode 697: Degree of an Array
Find the shortest contiguous subarray with the same degree as the whole array using frequency counts and first occurrence indices.
LeetCode 696: Count Binary Substrings
Count substrings with equal consecutive groups of 0s and 1s using run lengths.
LeetCode 695: Max Area of Island
Find the largest connected island area in a binary grid using depth-first search.
LeetCode 694: Number of Distinct Islands
Count unique island shapes in a binary grid using DFS and relative coordinates.
LeetCode 693: Binary Number with Alternating Bits
Check whether every adjacent bit in a positive integer's binary representation is different.
LeetCode 692: Top K Frequent Words
Find the k most frequent words using frequency counting and custom sorting by count and lexicographical order.
LeetCode 691: Stickers to Spell Word
Find the minimum number of stickers needed to form a target string using top-down dynamic programming with memoization.
LeetCode 690: Employee Importance
Compute the total importance of an employee and all direct and indirect subordinates using a hash map and depth-first search.
LeetCode 689: Maximum Sum of 3 Non-Overlapping Subarrays
Find three non-overlapping subarrays of length k with maximum total sum and return the lexicographically smallest starting indices.
LeetCode 688: Knight Probability in Chessboard
Compute the probability that a knight remains on an n x n chessboard after exactly k random moves using dynamic programming.
LeetCode 686: Repeated String Match
Find the minimum number of times one string must be repeated so another string becomes a substring.
LeetCode 685: Redundant Connection II
Find the directed edge to remove so a graph becomes a rooted tree again, handling both cycles and nodes with two parents.
LeetCode 684: Redundant Connection
Find the extra edge in an undirected graph that creates a cycle using Union-Find.
LeetCode 683: K Empty Slots
Find the earliest day when two turned-on bulbs have exactly k turned-off bulbs between them using a sliding window over bloom days.
LeetCode 682: Baseball Game
Simulate a baseball scoring system using a stack to process operations and compute the final score.
LeetCode 681: Next Closest Time
Find the next valid 24-hour time using only the digits from the current time.
LeetCode 680: Valid Palindrome II
Check whether a string can become a palindrome after deleting at most one character using two pointers.
LeetCode 679: 24 Game
Determine whether four numbers can be combined with arithmetic operations and parentheses to produce 24.
LeetCode 678: Valid Parenthesis String
Check whether a string containing parentheses and wildcard stars can be made valid using a greedy range of possible open counts.
LeetCode 677: Map Sum Pairs
Design a map that supports key-value insertion and prefix-sum queries using a hash map and trie.
LeetCode 676: Implement Magic Dictionary
Design a dictionary that can check whether a word can match a stored word after changing exactly one character.
LeetCode 675: Cut Off Trees for Golf Event
A clear explanation of cutting trees in increasing height order using repeated BFS on a grid.
LeetCode 674: Longest Continuous Increasing Subsequence
A clear explanation of finding the longest strictly increasing contiguous subarray using a single scan.
LeetCode 673: Number of Longest Increasing Subsequence
A clear explanation of counting how many longest strictly increasing subsequences exist using dynamic programming.
LeetCode 672: Bulb Switcher II
A clear explanation of counting possible bulb states after pressing four toggle buttons exactly presses times.
LeetCode 671: Second Minimum Node In a Binary Tree
A clear explanation of finding the second minimum value in a special binary tree using DFS.
LeetCode 670: Maximum Swap
A clear explanation of maximizing an integer by swapping at most two digits once.
LeetCode 669: Trim a Binary Search Tree
A clear explanation of trimming a BST so that all remaining node values lie inside a given inclusive range.
LeetCode 668: Kth Smallest Number in Multiplication Table
A clear explanation of finding the kth smallest value in an m by n multiplication table using binary search on answer.
LeetCode 667: Beautiful Arrangement II
A clear explanation of constructing an array with exactly k distinct adjacent differences using a greedy pattern.
LeetCode 666: Path Sum IV
A clear explanation of computing all root-to-leaf path sums from a compact three-digit binary tree encoding.
LeetCode 665: Non-decreasing Array
A clear explanation of checking whether an array can become non-decreasing by modifying at most one element.
LeetCode 664: Strange Printer
A clear explanation of minimizing printer turns using interval dynamic programming.
LeetCode 663: Equal Tree Partition
A clear explanation of checking whether a binary tree can be split into two equal-sum trees by removing one edge.
LeetCode 662: Maximum Width of Binary Tree
A clear explanation of computing the maximum width of a binary tree using level-order traversal and complete-tree indices.
LeetCode 661: Image Smoother
A clear explanation of averaging neighboring pixels in a matrix using direct simulation.
LeetCode 659: Split Array into Consecutive Subsequences
A clear explanation of deciding whether a sorted array can be split into consecutive subsequences of length at least three.
LeetCode 658: Find K Closest Elements
A clear explanation of finding the k closest elements to a target using binary search and a sliding window.
LeetCode 657: Robot Return to Origin
A clear explanation of determining whether a robot returns to the origin after executing movement instructions.
LeetCode 656: Coin Path
A clear explanation of finding the minimum-cost path with bounded jumps, blocked cells, and lexicographic tie-breaking.
LeetCode 655: Print Binary Tree
A clear explanation of formatting a binary tree into a 2D string matrix using tree height and recursive placement.
LeetCode 654: Maximum Binary Tree
A clear explanation of constructing a maximum binary tree recursively using divide and conquer.
LeetCode 653: Two Sum IV - Input is a BST
A clear explanation of finding whether two different nodes in a binary search tree sum to a target value.
LeetCode 652: Find Duplicate Subtrees
A clear explanation of finding duplicate binary tree subtrees using postorder traversal, serialization, and a hash map.
LeetCode 651: 4 Keys Keyboard
A dynamic programming solution for maximizing the number of A characters printed with a limited number of keyboard operations.
LeetCode 650: 2 Keys Keyboard
A dynamic programming and prime factorization solution for finding the minimum operations needed to produce n characters.
LeetCode 649: Dota2 Senate
A queue-based simulation for predicting which party wins after senators ban opponents in turn order.
LeetCode 648: Replace Words
A trie-based solution for replacing each derivative word with the shortest matching root.
LeetCode 647: Palindromic Substrings
A center expansion solution for counting every palindromic substring in a string.
LeetCode 646: Maximum Length of Pair Chain
A greedy interval scheduling solution for finding the longest chain of valid pairs.
LeetCode 645: Set Mismatch
A counting and math solution for finding the duplicated number and the missing number in a corrupted set.
LeetCode 644: Maximum Average Subarray II
A binary search solution for finding the maximum average of any contiguous subarray with length at least k.
LeetCode 643: Maximum Average Subarray I
A sliding window solution for finding the maximum average among all contiguous subarrays of fixed length k.
LeetCode 642: Design Search Autocomplete System
A trie-based design for returning the top three historical sentences for a typed prefix.
LeetCode 641: Design Circular Deque
An array-based circular buffer solution for implementing a fixed-size double-ended queue.
LeetCode 640: Solve the Equation
A string parsing solution for reducing a linear equation into coefficient and constant terms.
LeetCode 639: Decode Ways II
A dynamic programming solution for counting decodings of a digit string with wildcard characters.
LeetCode 638: Shopping Offers
A DFS and memoization solution for finding the minimum cost to satisfy item needs using individual prices and reusable special offers.
LeetCode 637: Average of Levels in Binary Tree
A breadth-first search solution for computing the average value of nodes at each level of a binary tree.
LeetCode 636: Exclusive Time of Functions
A stack-based solution for computing exclusive execution time from nested start and end logs.
LeetCode 635: Design Log Storage System
A design solution for storing timestamped logs and retrieving IDs by inclusive time range at a chosen granularity.
LeetCode 634: Find the Derangement of An Array
A dynamic programming and combinatorics solution for counting permutations with no fixed positions.
LeetCode 633: Sum of Square Numbers
A two-pointer and number theory solution for checking whether an integer can be written as the sum of two square numbers.
LeetCode 632: Smallest Range Covering Elements from K Lists
A heap-based solution for finding the smallest range that contains at least one number from each sorted list.
LeetCode 631: Design Excel Sum Formula
A design solution for a small Excel-like spreadsheet that supports set, get, and dynamic sum formulas.
LeetCode 630: Course Schedule III
A greedy heap solution for taking the maximum number of courses before their deadlines.
LeetCode 629: K Inverse Pairs Array
A dynamic programming solution for counting permutations of 1 to n with exactly k inverse pairs.
LeetCode 628: Maximum Product of Three Numbers
A clear explanation of finding the largest product of three numbers using sorting or constant-space tracking.
LeetCode 617: Merge Two Binary Trees
A recursive tree traversal guide for merging two binary trees node by node.
LeetCode 616: Add Bold Tag in String
A string-marking guide for adding bold tags around all matched words while merging overlapping and adjacent bold regions.
LeetCode 611: Valid Triangle Number
A two-pointer guide for counting triplets that can form valid triangles after sorting the side lengths.
LeetCode 609: Find Duplicate File in System
A hash map guide for grouping file paths by identical file content and returning only duplicate groups.
LeetCode 606: Construct String from Binary Tree
A recursive guide for converting a binary tree into a preorder parenthesized string while preserving the one-to-one mapping between the tree and the string.
LeetCode 605: Can Place Flowers
A greedy guide for determining whether a given number of flowers can be planted without violating the no-adjacent-flowers rule.
LeetCode 604: Design Compressed String Iterator
A guide to implementing a lazy iterator over a run-length encoded string without fully decompressing it.
LeetCode 242: Valid Anagram
A clear explanation of checking whether two strings are anagrams using character frequency counting.
LeetCode 241: Different Ways to Add Parentheses
A clear explanation of generating all possible results from different parenthesizations using divide and conquer recursion.
LeetCode 240: Search a 2D Matrix II
A clear explanation of searching a row-sorted and column-sorted matrix using the top-right corner elimination method.
LeetCode 239: Sliding Window Maximum
A clear explanation of finding the maximum value in every sliding window using a monotonic deque.
LeetCode 238: Product of Array Except Self
A clear explanation of computing each product except self using prefix and suffix products without division.
LeetCode 237: Delete Node in a Linked List
A clear explanation of deleting a node from a singly linked list when only that node is given.
LeetCode 236: Lowest Common Ancestor of a Binary Tree
A clear explanation of finding the lowest common ancestor in a normal binary tree using recursive depth-first search.
LeetCode 235: Lowest Common Ancestor of a Binary Search Tree
A clear explanation of finding the lowest common ancestor in a binary search tree using BST ordering properties.
LeetCode 234: Palindrome Linked List
A clear explanation of checking whether a singly linked list is a palindrome using fast and slow pointers plus in-place reversal.
LeetCode 233: Number of Digit One
A detailed explanation of counting how many times digit one appears from 0 to n using positional digit analysis.
LeetCode 232: Implement Queue using Stacks
A detailed explanation of implementing a FIFO queue using two LIFO stacks with amortized constant time operations.
LeetCode 231: Power of Two
A clear explanation of determining whether an integer is a power of two using binary properties and bit manipulation.
LeetCode 230: Kth Smallest Element in a BST
A clear explanation of finding the kth smallest value in a binary search tree using inorder traversal.
LeetCode 229: Majority Element II
A clear explanation of finding all elements that appear more than n/3 times using the extended Boyer-Moore voting algorithm.
LeetCode 228: Summary Ranges
A clear explanation of summarizing a sorted unique integer array into compact consecutive ranges.
LeetCode 227: Basic Calculator II
A detailed explanation of evaluating arithmetic expressions with stack-based parsing and operator precedence.
LeetCode 226: Invert Binary Tree
A clear explanation of inverting a binary tree using recursive depth-first traversal.
LeetCode 175: Combine Two Tables
A clear SQL guide for solving Combine Two Tables using LEFT JOIN.
LeetCode 50: Pow(x, n)
A clear explanation of Pow(x, n) using binary exponentiation to compute powers in logarithmic time.
LeetCode 49: Group Anagrams
A clear explanation of Group Anagrams using a hash map keyed by each word's sorted character signature.
LeetCode 48: Rotate Image
A clear explanation of Rotate Image using in-place matrix transpose and row reversal.
LeetCode 47: Permutations II
A clear explanation of Permutations II using sorting, depth-first search, and duplicate-skipping backtracking.
LeetCode 46: Permutations
A clear explanation of Permutations using depth-first search and backtracking.
LeetCode 45: Jump Game II
A clear explanation of Jump Game II using a greedy range expansion approach to find the minimum number of jumps.
LeetCode 44: Wildcard Matching
A clear explanation of Wildcard Matching using dynamic programming over string and pattern prefixes.
LeetCode 43: Multiply Strings
A clear explanation of Multiply Strings using grade-school multiplication with digit arrays.
LeetCode 42: Trapping Rain Water
A clear explanation of the Trapping Rain Water problem using left and right boundaries, then an optimized two-pointer solution.
LeetCode 41: First Missing Positive
A clear explanation of the First Missing Positive problem using in-place index placement to achieve O(n) time and O(1) extra space.
LeetCode 700: Search in a Binary Search Tree
Search for a target value in a binary search tree and return the subtree rooted at the matching node.
LeetCode 687: Longest Univalue Path
Find the longest path in a binary tree where every node on the path has the same value using depth-first search.
LeetCode 660: Remove 9
A clear explanation of finding the nth positive integer that does not contain the digit 9 using base-9 conversion.
LeetCode 600: Non-negative Integers without Consecutive Ones
A clear digit dynamic programming solution for counting numbers whose binary representation does not contain consecutive ones.
LeetCode 599: Minimum Index Sum of Two Lists
A clear hash map solution for finding common strings with the smallest index sum.
LeetCode 598: Range Addition II
A clear math solution for counting the maximum values after repeated top-left matrix increment operations.
LeetCode 594: Longest Harmonious Subsequence
A clear hash map solution for finding the longest subsequence whose maximum and minimum differ by exactly one.
LeetCode 593: Valid Square
A clear geometry solution for checking whether four unordered points form a valid square.
LeetCode 592: Fraction Addition and Subtraction
A clear parsing and math solution for evaluating fraction addition and subtraction expressions.
LeetCode 591: Tag Validator
A clear stack-based parser for validating nested XML-like tags with CDATA sections.
LeetCode 590: N-ary Tree Postorder Traversal
A clear DFS solution for returning the postorder traversal of an N-ary tree.
LeetCode 589: N-ary Tree Preorder Traversal
A clear DFS solution for returning the preorder traversal of an N-ary tree.
LeetCode 588: Design In-Memory File System
A clear design guide for implementing an in-memory file system with directory listing, directory creation, file append, and file read operations.
LeetCode 587: Erect the Fence
A clear convex hull solution for returning all trees that lie on the fence boundary.
LeetCode 583: Delete Operation for Two Strings
A clear dynamic programming solution for finding the minimum deletions needed to make two strings equal.
LeetCode 582: Kill Process
A clear graph traversal solution for finding all processes terminated when killing a target process.
LeetCode 581: Shortest Unsorted Continuous Subarray
A clear linear-time solution for finding the shortest subarray that must be sorted to make the whole array sorted.
LeetCode 576: Out of Boundary Paths
A clear dynamic programming solution for counting paths that move a ball out of a grid boundary.
LeetCode 575: Distribute Candies
A clear explanation of Distribute Candies using a set to count candy types and a simple limit argument.
LeetCode 573: Squirrel Simulation
A clear explanation of Squirrel Simulation using Manhattan distance and the special first trip.
LeetCode 572: Subtree of Another Tree
A clear explanation of Subtree of Another Tree using recursive tree matching and DFS.
LeetCode 568: Maximum Vacation Days
A clear explanation of Maximum Vacation Days using dynamic programming over weeks and cities.
LeetCode 567: Permutation in String
A clear explanation of Permutation in String using a fixed-size sliding window and character frequency counts.
LeetCode 566: Reshape the Matrix
A clear explanation of Reshape the Matrix using index mapping from the original matrix to the reshaped matrix.
LeetCode 565: Array Nesting
A clear explanation of Array Nesting using cycle detection over a permutation.
LeetCode 564: Find the Closest Palindrome
A clear explanation of Find the Closest Palindrome using prefix mirroring and a small candidate set.
LeetCode 563: Binary Tree Tilt
A clear explanation of Binary Tree Tilt using postorder DFS to compute subtree sums and accumulate tilt.
LeetCode 562: Longest Line of Consecutive One in Matrix
A clear explanation of Longest Line of Consecutive One in Matrix using dynamic programming over four directions.
LeetCode 561: Array Partition
A clear explanation of Array Partition using sorting and adjacent pairing to maximize the sum of pair minimums.
LeetCode 560: Subarray Sum Equals K
A clear explanation of Subarray Sum Equals K using prefix sums and a hash map to count matching subarrays in linear time.
LeetCode 559: Maximum Depth of N-ary Tree
A clear explanation of Maximum Depth of N-ary Tree using recursive depth-first search.
LeetCode 557: Reverse Words in a String III
A clear explanation of Reverse Words in a String III using two-pointer scanning and string reversal.
LeetCode 556: Next Greater Element III
A clear explanation of Next Greater Element III using the next permutation algorithm on the digits of an integer.
LeetCode 555: Split Concatenated Strings
A clear explanation of Split Concatenated Strings using string reversal choices and enumeration of every possible cut point.
LeetCode 554: Brick Wall
A clear explanation of Brick Wall using prefix sums and a hash map to find the best vertical cut position.
LeetCode 553: Optimal Division
A clear explanation of Optimal Division using the structure of division expressions to build the maximum-value expression.
LeetCode 552: Student Attendance Record II
A clear explanation of Student Attendance Record II using dynamic programming over absence count and late streak.
LeetCode 551: Student Attendance Record I
A clear explanation of Student Attendance Record I using simple string checks and a one-pass counter solution.
LeetCode 549: Binary Tree Longest Consecutive Sequence II
A clear explanation of finding the longest increasing or decreasing consecutive path in a binary tree using DFS.
LeetCode 548: Split Array with Equal Sum
A clear explanation of splitting an array into four equal-sum parts using prefix sums and set-based search.
LeetCode 547: Number of Provinces
A clear explanation of counting connected components in an undirected graph represented by an adjacency matrix.
LeetCode 546: Remove Boxes
A clear explanation of maximizing remove-box scores using interval dynamic programming with memoization.
LeetCode 545: Boundary of Binary Tree
A clear explanation of collecting the boundary of a binary tree using separate left boundary, leaves, and right boundary traversals.
LeetCode 544: Output Contest Matches
A clear explanation of building the final tournament bracket by repeatedly pairing strongest and weakest teams.
LeetCode 543: Diameter of Binary Tree
A clear explanation of finding the longest path between any two nodes in a binary tree using DFS height computation.
LeetCode 542: 01 Matrix
A clear explanation of computing the distance to the nearest zero in a binary matrix using multi-source BFS.
LeetCode 541: Reverse String II
A clear explanation of reversing the first k characters in every 2k block of a string.
LeetCode 540: Single Element in a Sorted Array
A clear explanation of finding the only non-duplicate element in a sorted array using binary search.
LeetCode 539: Minimum Time Difference
A clear explanation of finding the minimum difference between 24-hour clock times using minute conversion and sorting.
LeetCode 538: Convert BST to Greater Tree
A clear explanation of converting a BST into a greater tree using reverse inorder traversal and a running sum.
LeetCode 537: Complex Number Multiplication
A clear explanation of multiplying complex numbers represented as strings using algebraic expansion.
LeetCode 536: Construct Binary Tree from String
A clear explanation of parsing a parenthesized string recursively to construct a binary tree.
LeetCode 535: Encode and Decode TinyURL
A clear explanation of designing a simple URL encoder and decoder using a hash map and generated keys.
LeetCode 533: Lonely Pixel II
A clear explanation of counting black lonely pixels using row counts, column counts, and duplicate row patterns.
LeetCode 532: K-diff Pairs in an Array
A clear explanation of counting unique pairs whose absolute difference is k using frequency counting.
LeetCode 531: Lonely Pixel I
A clear explanation of counting black pixels that are alone in both their row and column.
LeetCode 530: Minimum Absolute Difference in BST
A clear explanation of finding the minimum difference between two BST node values using inorder traversal.
LeetCode 529: Minesweeper
A clear explanation of updating a Minesweeper board using DFS flood fill and adjacent mine counting.
LeetCode 528: Random Pick with Weight
A clear explanation of weighted random sampling using prefix sums and binary search.
LeetCode 527: Word Abbreviation
A clear explanation of generating minimal unique word abbreviations using grouping and trie prefixes.
LeetCode 526: Beautiful Arrangement
A clear explanation of counting beautiful arrangements using backtracking and divisibility pruning.
LeetCode 525: Contiguous Array
A clear explanation of finding the longest contiguous subarray with equal numbers of 0 and 1 using prefix sums and a hash map.
LeetCode 524: Longest Word in Dictionary through Deleting
A clear explanation of finding the longest dictionary word obtainable as a subsequence using two pointers and sorting rules.
LeetCode 523: Continuous Subarray Sum
A clear explanation of detecting a subarray whose sum is a multiple of k using prefix sums and modular arithmetic.
LeetCode 522: Longest Uncommon Subsequence II
A clear explanation of finding the longest uncommon subsequence among many strings using subsequence checks.
LeetCode 519: Random Flip Matrix
A clear explanation of randomly flipping zero cells in a matrix without repetition using hash mapping and virtual swapping.
LeetCode 518: Coin Change II
A clear explanation of counting coin-change combinations using dynamic programming.
LeetCode 517: Super Washing Machines
A clear explanation of balancing dresses across washing machines using greedy prefix flow.
LeetCode 515: Find Largest Value in Each Tree Row
A clear explanation of finding the maximum value at every depth of a binary tree using level-order traversal.
LeetCode 514: Freedom Trail
A clear explanation of finding the minimum steps to spell a key on a circular ring using dynamic programming and memoized DFS.
LeetCode 513: Find Bottom Left Tree Value
A clear explanation of finding the leftmost value in the deepest row of a binary tree using level-order traversal.
LeetCode 510: Inorder Successor in BST II
A clear explanation of finding the inorder successor in a binary search tree when nodes contain parent pointers.
LeetCode 508: Most Frequent Subtree Sum
A clear explanation of finding the most frequent subtree sum in a binary tree using postorder DFS and a frequency map.
LeetCode 506: Relative Ranks
A clear explanation of assigning athlete ranks from scores using sorting while preserving original indices.
LeetCode 505: The Maze II
A clear explanation of finding the shortest rolling distance in a maze using Dijkstra’s algorithm.
LeetCode 503: Next Greater Element II
A clear explanation of finding the next greater element in a circular array using a monotonic stack.
LeetCode 502: IPO
A clear explanation of maximizing capital by selecting at most k projects using sorting and a max heap.
LeetCode 501: Find Mode in Binary Search Tree
A clear explanation of finding the most frequent value or values in a binary search tree using inorder traversal.
LeetCode 521: Longest Uncommon Subsequence I
A clear explanation of finding the longest uncommon subsequence between two strings using simple case analysis.
LeetCode 520: Detect Capital
A clear explanation of checking whether a word uses capital letters correctly by counting uppercase letters.
LeetCode 516: Longest Palindromic Subsequence
A clear explanation of finding the length of the longest palindromic subsequence using interval dynamic programming.
LeetCode 512: Game Play Analysis II
A clear explanation of finding the first device used by each player using SQL aggregation and a join.
LeetCode 511: Game Play Analysis I
A clear explanation of finding each player's first login date using SQL aggregation.
LeetCode 509: Fibonacci Number
A clear explanation of computing Fibonacci numbers using dynamic programming and iterative state transitions.
LeetCode 507: Perfect Number
A clear explanation of checking whether a number equals the sum of its positive divisors excluding itself.
LeetCode 504: Base 7
A clear explanation of converting an integer into its base 7 string representation using repeated division.
LeetCode 558: Logical OR of Two Binary Grids Represented as Quad-Trees
A clear explanation of merging two quad-trees using recursive logical OR operations.
LeetCode 550: Game Play Analysis IV
A clear explanation of calculating the fraction of players who logged in again the day after their first login.
LeetCode 534: Game Play Analysis III
A clear explanation of computing cumulative games played per player and date using SQL window functions.
LeetCode 500: Keyboard Row
A clear explanation of filtering words that can be typed using only one row of an American keyboard.
LeetCode 499: The Maze III
A clear explanation of finding the shortest rolling-ball path to the hole using Dijkstra with lexicographic tie-breaking.
LeetCode 498: Diagonal Traverse
A clear explanation of returning matrix elements in diagonal zigzag order by grouping cells with the same row plus column index.
LeetCode 497: Random Point in Non-overlapping Rectangles
A clear explanation of uniformly picking an integer point from non-overlapping rectangles using prefix sums and binary search.
LeetCode 496: Next Greater Element I
A clear explanation of finding the next greater element using a monotonic decreasing stack and hash map.
LeetCode 495: Teemo Attacking
A clear explanation of calculating total poisoned duration by merging overlapping attack intervals.
LeetCode 494: Target Sum
A clear explanation of counting sign assignments that reach a target using recursion first, then subset-sum dynamic programming.
LeetCode 493: Reverse Pairs
A clear explanation of counting pairs where nums[i] is greater than twice nums[j] using merge sort.
LeetCode 492: Construct the Rectangle
A clear explanation of finding rectangle dimensions with a fixed area and the smallest length-width difference.
LeetCode 491: Non-decreasing Subsequences
A clear explanation of generating all distinct non-decreasing subsequences using DFS, backtracking, and per-level duplicate control.
LeetCode 490: The Maze
A clear explanation of deciding whether a rolling ball can stop at the destination using BFS or DFS over stopping cells.
LeetCode 489: Robot Room Cleaner
A clear explanation of cleaning an unknown grid using DFS, relative coordinates, and physical backtracking.
LeetCode 488: Zuma Game
A clear explanation of solving Zuma Game with DFS, memoization, and chain-removal simulation.
LeetCode 487: Max Consecutive Ones II
A clear explanation of finding the longest run of 1s after flipping at most one 0 using a sliding window.
LeetCode 486: Predict the Winner
A clear explanation of predicting whether Player 1 can win using minimax dynamic programming over score difference.
LeetCode 485: Max Consecutive Ones
A clear explanation of finding the longest streak of 1s in a binary array with a single pass.
LeetCode 484: Find Permutation
A clear explanation of constructing the lexicographically smallest permutation that matches an I and D pattern.
LeetCode 483: Smallest Good Base
A clear explanation of finding the smallest base where n is written as all ones using geometric series and binary search.
LeetCode 482: License Key Formatting
A clear explanation of reformatting a license key by removing dashes, uppercasing characters, and grouping from the right.
LeetCode 481: Magical String
A clear explanation of constructing the magical string by using the string itself as run-length instructions.
LeetCode 480: Sliding Window Median
A clear explanation of maintaining the median of each fixed-size window using two heaps and lazy deletion.
LeetCode 479: Largest Palindrome Product
A clear explanation of finding the largest palindrome made from the product of two n-digit numbers by generating palindrome candidates directly.
LeetCode 478: Generate Random Point in a Circle
A clear explanation of generating uniformly random points inside a circle using polar coordinates.
LeetCode 477: Total Hamming Distance
A clear explanation of computing the total Hamming distance across all pairs by counting different bits column by column.
LeetCode 476: Number Complement
A clear explanation of finding the bitwise complement of a positive integer using a binary mask.
LeetCode 475: Heaters
A clear explanation of finding the minimum heater radius by sorting positions and matching each house to its nearest heater.
LeetCode 474: Ones and Zeroes
A clear explanation of solving the largest subset problem as a two-dimensional 0/1 knapsack over zero and one counts.
LeetCode 473: Matchsticks to Square
A clear explanation of deciding whether matchsticks can form a square using backtracking, sorting, and pruning.
LeetCode 472: Concatenated Words
A clear explanation of finding all words that can be formed by concatenating at least two shorter words from the same list.
LeetCode 471: Encode String with Shortest Length
A clear explanation of interval dynamic programming for encoding a string into the shortest k[encoded_string] form.
LeetCode 470: Implement Rand10() Using Rand7()
A clear explanation of generating a uniform random integer from 1 to 10 using only rand7 and rejection sampling.
LeetCode 469: Convex Polygon
A clear explanation of checking whether ordered points form a convex polygon using cross products.
LeetCode 468: Validate IP Address
A clear explanation of validating IPv4 and IPv6 addresses by checking segment count, length, characters, range, and leading-zero rules.
LeetCode 467: Unique Substrings in Wraparound String
A clear explanation of counting unique substrings that appear in the infinite alphabet wraparound string using dynamic programming by ending character.
LeetCode 466: Count The Repetitions
A clear explanation of counting how many repeated copies of one string can be obtained as a subsequence of another repeated string.
LeetCode 465: Optimal Account Balancing
A clear explanation of minimizing debt-settlement transactions using net balances, backtracking, and memoization-style pruning.
LeetCode 464: Can I Win
A clear explanation of solving the Can I Win game using minimax recursion, bitmask state compression, and memoization.
LeetCode 463: Island Perimeter
A clear explanation of counting the perimeter of an island in a grid by adding land-cell edges and subtracting shared edges.
LeetCode 462: Minimum Moves to Equal Array Elements II
A clear explanation of why the median minimizes the number of moves needed to make all array elements equal.
LeetCode 461: Hamming Distance
A clear explanation of computing the Hamming distance between two integers using XOR and bit counting.
LeetCode 460: LFU Cache
A clear explanation of designing an LFU cache with O(1) average get and put operations.
LeetCode 459: Repeated Substring Pattern
A clear explanation of checking whether a string can be built by repeating one of its proper substrings.
LeetCode 458: Poor Pigs
A clear explanation of the combinatorics behind finding the minimum number of pigs needed to identify the poisonous bucket.
LeetCode 457: Circular Array Loop
A clear explanation of detecting a valid cycle in a circular array using fast and slow pointers.
LeetCode 456: 132 Pattern
A clear explanation of detecting a 132 pattern using reverse traversal and a monotonic stack.
LeetCode 455: Assign Cookies
A clear explanation of the greedy two-pointer solution for maximizing the number of content children.
LeetCode 454: 4Sum II
A clear explanation of counting zero-sum tuples across four arrays using pair sums and a hash map.
LeetCode 453: Minimum Moves to Equal Array Elements
A clear explanation of the math behind making all array elements equal by incrementing n - 1 elements at a time.
LeetCode 452: Minimum Number of Arrows to Burst Balloons
A clear explanation of the greedy interval solution for finding the minimum number of arrows needed to burst all balloons.
LeetCode 451: Sort Characters By Frequency
A clear explanation of sorting characters by decreasing frequency using a hash map and sorting.
LeetCode 450: Delete Node in a BST
Delete a node from a binary search tree while preserving the BST property using recursive search and inorder successor replacement.
LeetCode 449: Serialize and Deserialize BST
Serialize a binary search tree compactly with preorder traversal and rebuild it using BST value bounds.
LeetCode 448: Find All Numbers Disappeared in an Array
Find all missing numbers from 1 to n in O(n) time using in-place index marking.
LeetCode 447: Number of Boomerangs
Count ordered boomerang tuples by fixing each point as the center and grouping other points by squared distance.
LeetCode 446: Arithmetic Slices II - Subsequence
Count arithmetic subsequences of length at least three using dynamic programming with one hash map per ending index.
LeetCode 445: Add Two Numbers II
Add two numbers stored in forward-order linked lists using stacks and carry propagation.
LeetCode 444: Sequence Reconstruction
Check whether nums is the unique shortest supersequence of given subsequences using topological sorting.
LeetCode 443: String Compression
Compress a character array in-place using two pointers and grouped character counting.
LeetCode 442: Find All Duplicates in an Array
Find all duplicated numbers in an array in O(n) time and O(1) extra space using index marking.
LeetCode 441: Arranging Coins
Find the maximum number of complete staircase rows that can be formed using binary search and triangular numbers.
LeetCode 440: K-th Smallest in Lexicographical Order
Find the k-th integer in lexicographical order without generating all numbers, using prefix counting over a conceptual trie.
LeetCode 439: Ternary Expression Parser
Evaluate a nested ternary expression using a right-to-left stack parser.
LeetCode 438: Find All Anagrams in a String
Find all starting indices where an anagram of p appears in s using a fixed-size sliding window.
LeetCode 437: Path Sum III
Count downward paths in a binary tree whose values sum to targetSum using DFS and prefix sums.
LeetCode 436: Find Right Interval
Find, for each interval, the interval with the smallest start point greater than or equal to its end point using sorting and binary search.
LeetCode 435: Non-overlapping Intervals
Remove the minimum number of intervals so the remaining intervals do not overlap, using greedy sorting by end time.
LeetCode 434: Number of Segments in a String
Count the number of word segments in a string by detecting transitions from spaces to non-space characters.
LeetCode 433: Minimum Genetic Mutation
Find the minimum number of valid one-character gene mutations using breadth-first search.
LeetCode 432: All O'one Data Structure
Design a data structure that supports increment, decrement, get minimum key, and get maximum key in average O(1) time.
LeetCode 431: Encode N-ary Tree to Binary Tree
Convert an N-ary tree into a binary tree and reconstruct it using the left-child right-sibling representation.
LeetCode 430: Flatten a Multilevel Doubly Linked List
Flatten a multilevel doubly linked list in-place using depth-first traversal and pointer splicing.
LeetCode 429: N-ary Tree Level Order Traversal
Traverse an N-ary tree level by level using breadth-first search.
LeetCode 428: Serialize and Deserialize N-ary Tree
Serialize an N-ary tree into a string and reconstruct the same tree using preorder traversal with child counts.
LeetCode 427: Construct Quad Tree
Build a quad tree from a binary square grid using recursive divide and conquer.
LeetCode 426: Convert Binary Search Tree to Sorted Doubly Linked List
Convert a BST into a sorted circular doubly linked list in-place using inorder traversal.
LeetCode 425: Word Squares
A clear explanation of building all word squares using backtracking with prefix pruning.
LeetCode 424: Longest Repeating Character Replacement
A clear explanation of finding the longest substring that can become all one letter using a sliding window.
LeetCode 423: Reconstruct Original Digits from English
A clear explanation of reconstructing digits from shuffled English words using character frequency counts and unique identifying letters.
LeetCode 422: Valid Word Square
A clear explanation of checking whether rows and columns read the same using direct index comparison.
LeetCode 421: Maximum XOR of Two Numbers in an Array
A clear explanation of finding the maximum XOR of two numbers using greedy bit prefixes.
LeetCode 419: Battleships in a Board
A clear explanation of counting battleships in a board using one-pass observation without modifying the grid.
LeetCode 418: Sentence Screen Fitting
A clear explanation of fitting a sentence onto a screen using cyclic string simulation and greedy row transitions.
LeetCode 417: Pacific Atlantic Water Flow
A clear explanation of finding cells that can flow to both oceans using reverse graph traversal from the borders.
LeetCode 416: Partition Equal Subset Sum
A clear explanation of deciding whether an array can be split into two equal-sum subsets using 0/1 knapsack dynamic programming.
LeetCode 415: Add Strings
A clear explanation of adding two non-negative integer strings using manual digit-by-digit simulation.
LeetCode 414: Third Maximum Number
A clear explanation of finding the third distinct maximum number using one pass and constant space.
LeetCode 413: Arithmetic Slices
A clear explanation of counting arithmetic subarrays using dynamic programming and consecutive differences.
LeetCode 412: Fizz Buzz
A clear explanation of the Fizz Buzz problem using direct simulation and divisibility checks.
LeetCode 411: Minimum Unique Word Abbreviation
A clear explanation of finding the shortest abbreviation that does not conflict with any dictionary word using bit masks.
LeetCode 409: Longest Palindrome
A clear explanation of finding the longest palindrome length that can be built from given letters using character counts.
LeetCode 407: Trapping Rain Water II
A clear explanation of trapping rain water in a 2D elevation map using a min heap and boundary expansion.
LeetCode 404: Sum of Left Leaves
A clear explanation of the Sum of Left Leaves problem using depth-first traversal of a binary tree.
LeetCode 403: Frog Jump
A clear explanation of the Frog Jump problem using dynamic programming with reachable jump sizes.
LeetCode 420: Strong Password Checker
A clear explanation of checking the minimum edits needed to make a password strong using greedy handling of length, missing character types, and repeated runs.
LeetCode 410: Split Array Largest Sum
A clear explanation of minimizing the largest subarray sum using binary search on the answer and greedy validation.
LeetCode 408: Valid Word Abbreviation
A clear explanation of validating a word abbreviation using two pointers and number parsing.
LeetCode 406: Queue Reconstruction by Height
A clear explanation of reconstructing a queue using greedy sorting and indexed insertion.
LeetCode 405: Convert a Number to Hexadecimal
A clear explanation of converting integers to hexadecimal using bit manipulation and two's complement representation.
LeetCode 402: Remove K Digits
A clear explanation of the Remove K Digits problem using a greedy monotonic stack.
LeetCode 401: Binary Watch
A clear explanation of the Binary Watch problem using bit counting over all valid times.
LeetCode 400: Nth Digit
A clear explanation of finding the nth digit in the infinite integer sequence using digit groups and arithmetic.
LeetCode 399: Evaluate Division
A clear explanation of solving division equations using graph traversal and weighted edges.
LeetCode 398: Random Pick Index
A clear explanation of picking a uniformly random index for a target value using reservoir sampling, with an alternative hash map approach.
LeetCode 397: Integer Replacement
A clear explanation of reducing an integer to 1 with the fewest operations using greedy bit decisions.
LeetCode 396: Rotate Function
A clear explanation of maximizing the rotation function using a recurrence instead of simulating every rotation.
LeetCode 395: Longest Substring with At Least K Repeating Characters
A clear explanation of finding the longest substring where every character appears at least k times using divide and conquer.
LeetCode 394: Decode String
A clear explanation of decoding nested repeat expressions using a stack.
LeetCode 393: UTF-8 Validation
A clear explanation of validating a byte sequence as UTF-8 using bit masks and a continuation-byte counter.
LeetCode 392: Is Subsequence
A clear explanation of checking whether one string is a subsequence of another using two pointers.
LeetCode 391: Perfect Rectangle
A clear explanation of checking whether many small axis-aligned rectangles form one exact rectangular cover using area and corner parity.
LeetCode 390: Elimination Game
A clear explanation of finding the last remaining number after alternating left-to-right and right-to-left eliminations.
LeetCode 389: Find the Difference
A clear explanation of finding the extra character added to a shuffled string using counting and XOR.
LeetCode 388: Longest Absolute File Path
A clear explanation of computing the longest absolute path to a file from a serialized file system string using path lengths by depth.
LeetCode 387: First Unique Character in a String
A clear explanation of finding the first non-repeating character in a string using character frequency counting.
LeetCode 386: Lexicographical Numbers
A clear explanation of generating numbers from 1 to n in lexicographical order using an iterative DFS-style traversal.
LeetCode 385: Mini Parser
A clear explanation of parsing a serialized nested integer string using a stack.
LeetCode 384: Shuffle an Array
A clear explanation of shuffling an array uniformly using the Fisher-Yates algorithm while supporting reset.
LeetCode 383: Ransom Note
A clear explanation of checking whether one string can be constructed from another using character frequency counting.
LeetCode 382: Linked List Random Node
A clear explanation of selecting a random linked list node with equal probability using reservoir sampling.
LeetCode 381: Insert Delete GetRandom O(1) - Duplicates Allowed
A clear explanation of designing a randomized multiset with average O(1) insert, remove, and getRandom operations.
LeetCode 380: Insert Delete GetRandom O(1)
A clear explanation of designing a randomized set with average O(1) insert, remove, and getRandom operations.
LeetCode 379: Design Phone Directory
A clear explanation of designing a phone directory that can allocate, check, and release numbers efficiently.
LeetCode 378: Kth Smallest Element in a Sorted Matrix
A clear explanation of finding the kth smallest value in a row-sorted and column-sorted matrix using binary search on values.
LeetCode 377: Combination Sum IV
A clear explanation of Combination Sum IV using dynamic programming to count ordered combinations that sum to a target.
LeetCode 376: Wiggle Subsequence
A clear explanation of the Wiggle Subsequence problem using dynamic programming intuition and an optimized greedy solution.
LeetCode 375: Guess Number Higher or Lower II
A clear explanation of finding the minimum guaranteed cost using interval dynamic programming.
LeetCode 374: Guess Number Higher or Lower
A clear explanation of finding the picked number using binary search and the guess API.
LeetCode 373: Find K Pairs with Smallest Sums
A clear explanation of finding the k smallest pair sums from two sorted arrays using a min heap and best-first search.
LeetCode 372: Super Pow
A clear explanation of computing large modular exponentiation using fast power, modular arithmetic, and digit decomposition.
LeetCode 371: Sum of Two Integers
A clear explanation of adding two integers without using plus or minus by using XOR, AND, carry, and a 32-bit mask.
LeetCode 370: Range Addition
A clear explanation of applying many range updates efficiently using a difference array and prefix sums.
LeetCode 369: Plus One Linked List
A clear explanation of adding one to a number stored as a linked list using the rightmost non-nine digit.
LeetCode 368: Largest Divisible Subset
A clear explanation of finding the largest subset where every pair is divisible using sorting, dynamic programming, and parent reconstruction.
LeetCode 367: Valid Perfect Square
A clear explanation of checking whether an integer is a perfect square using binary search without sqrt.
LeetCode 366: Find Leaves of Binary Tree
A clear explanation of grouping binary tree nodes by the round in which they become leaves using postorder DFS.
LeetCode 365: Water and Jug Problem
A clear explanation of solving the Water and Jug Problem using Bézout's identity and greatest common divisor.
LeetCode 364: Nested List Weight Sum II
A clear explanation of computing inverse depth weighted sum using level-order traversal.
LeetCode 363: Max Sum of Rectangle No Larger Than K
A clear explanation of reducing a 2D rectangle problem to a 1D prefix-sum problem with binary search.
LeetCode 362: Design Hit Counter
A clear explanation of designing a hit counter for the last 5 minutes using a queue with compressed timestamps.
LeetCode 361: Bomb Enemy
A clear explanation of finding the best bomb placement in a grid using cached row and column segment counts.
LeetCode 360: Sort Transformed Array
A clear explanation of sorting values after applying a quadratic function using two pointers.
LeetCode 359: Logger Rate Limiter
A clear explanation of designing a logger that prints each message at most once every 10 seconds using a hash map.
LeetCode 358: Rearrange String k Distance Apart
A clear explanation of rearranging a string so equal characters are at least k positions apart using a heap and cooldown queue.
LeetCode 357: Count Numbers with Unique Digits
A clear explanation of counting numbers with unique digits using combinatorics.
LeetCode 356: Line Reflection
A clear explanation of checking whether 2D points are symmetric around a vertical line using min and max x-coordinates.
LeetCode 355: Design Twitter
A clear explanation of implementing a simplified Twitter using hash maps, sets, timestamps, and a heap.
LeetCode 354: Russian Doll Envelopes
A clear explanation of solving Russian Doll Envelopes using sorting and longest increasing subsequence.
LeetCode 353: Design Snake Game
A clear explanation of implementing Snake Game with a deque for body order and a set for constant-time collision checks.
LeetCode 352: Data Stream as Disjoint Intervals
A clear explanation of maintaining disjoint sorted intervals from a stream using insertion and merging.
LeetCode 351: Android Unlock Patterns
A clear explanation of Android Unlock Patterns using backtracking, a jump table, and symmetry optimization.
LeetCode 350: Intersection of Two Arrays II
A clear explanation of Intersection of Two Arrays II using frequency counting.
LeetCode 349: Intersection of Two Arrays
A clear explanation of Intersection of Two Arrays using hash sets for uniqueness and fast lookup.
LeetCode 348: Design Tic-Tac-Toe
A clear explanation of Design Tic-Tac-Toe using row, column, and diagonal counters for constant-time winner checks.
LeetCode 347: Top K Frequent Elements
A clear explanation of Top K Frequent Elements using frequency counting and bucket sort.
LeetCode 346: Moving Average from Data Stream
A clear explanation of Moving Average from Data Stream using a queue and rolling sum.
LeetCode 345: Reverse Vowels of a String
A clear explanation of Reverse Vowels of a String using two pointers and selective swaps.
LeetCode 344: Reverse String
A clear explanation of Reverse String using two pointers and in-place swaps.
LeetCode 343: Integer Break
A clear explanation of Integer Break using dynamic programming, with a note on the greedy math solution.
LeetCode 342: Power of Four
A clear explanation of Power of Four using bit manipulation and binary properties.
LeetCode 341: Flatten Nested List Iterator
A clear explanation of Flatten Nested List Iterator using lazy stack-based flattening.
LeetCode 340: Longest Substring with At Most K Distinct Characters
A clear explanation of Longest Substring with At Most K Distinct Characters using a sliding window and character counts.
LeetCode 339: Nested List Weight Sum
A clear explanation of Nested List Weight Sum using depth-first search over a nested structure.
LeetCode 338: Counting Bits
A clear explanation of Counting Bits using dynamic programming and bit manipulation.
LeetCode 337: House Robber III
A clear explanation of House Robber III using tree dynamic programming with rob and skip states.
LeetCode 336: Palindrome Pairs
A clear explanation of Palindrome Pairs using reversed-word lookup and palindrome split checks.
LeetCode 335: Self Crossing
A clear explanation of Self Crossing using constant-space checks for the only possible crossing patterns.
LeetCode 334: Increasing Triplet Subsequence
A clear explanation of Increasing Triplet Subsequence using greedy tracking of two minimum values.
LeetCode 333: Largest BST Subtree
A clear explanation of Largest BST Subtree using postorder traversal and subtree state propagation.
LeetCode 332: Reconstruct Itinerary
A clear explanation of Reconstruct Itinerary using a directed graph and Hierholzer's algorithm.
LeetCode 331: Verify Preorder Serialization of a Binary Tree
A clear explanation of verifying preorder serialization using slot counting without reconstructing the tree.
LeetCode 330: Patching Array
A clear explanation of Patching Array using a greedy smallest-missing-sum invariant.
LeetCode 329: Longest Increasing Path in a Matrix
A clear explanation of Longest Increasing Path in a Matrix using DFS with memoization.
LeetCode 328: Odd Even Linked List
A clear explanation of Odd Even Linked List using in-place pointer rewiring.
LeetCode 327: Count of Range Sum
A clear explanation of Count of Range Sum using prefix sums and merge sort counting.
LeetCode 326: Power of Three
A clear explanation of the Power of Three problem using repeated division and integer arithmetic.
LeetCode 325: Maximum Size Subarray Sum Equals k
A clear explanation of Maximum Size Subarray Sum Equals k using prefix sums and earliest-index hashing.
LeetCode 324: Wiggle Sort II
A clear explanation of Wiggle Sort II using sorting, median splitting, and virtual indexing.
LeetCode 323: Number of Connected Components in an Undirected Graph
A clear explanation of counting connected components using Union-Find and graph traversal.
LeetCode 322: Coin Change
A clear explanation of Coin Change using dynamic programming for minimum coin count.
LeetCode 321: Create Maximum Number
A clear explanation of Create Maximum Number using monotonic stacks for subsequences and greedy merging.
LeetCode 320: Generalized Abbreviation
A clear explanation of Generalized Abbreviation using backtracking to choose whether each character is kept or abbreviated.
LeetCode 319: Bulb Switcher
A clear explanation of Bulb Switcher using divisor parity and perfect squares.
LeetCode 318: Maximum Product of Word Lengths
A clear explanation of Maximum Product of Word Lengths using bit masks to test disjoint character sets efficiently.
LeetCode 317: Shortest Distance from All Buildings
A clear explanation of Shortest Distance from All Buildings using BFS from each building with distance and reach accumulation.
LeetCode 316: Remove Duplicate Letters
A clear explanation of Remove Duplicate Letters using a greedy monotonic stack.
LeetCode 315: Count of Smaller Numbers After Self
A clear explanation of Count of Smaller Numbers After Self using coordinate compression and a Fenwick Tree.
LeetCode 314: Binary Tree Vertical Order Traversal
A clear explanation of Binary Tree Vertical Order Traversal using BFS with column indices.
LeetCode 313: Super Ugly Number
A clear explanation of Super Ugly Number using dynamic programming with one pointer per prime.
LeetCode 312: Burst Balloons
A clear explanation of Burst Balloons using interval dynamic programming and the last-burst idea.
LeetCode 311: Sparse Matrix Multiplication
A clear explanation of Sparse Matrix Multiplication using non-zero entries to avoid wasted work.
LeetCode 310: Minimum Height Trees
A clear explanation of Minimum Height Trees using leaf trimming to find the center of a tree.
LeetCode 309: Best Time to Buy and Sell Stock with Cooldown
A clear explanation of Best Time to Buy and Sell Stock with Cooldown using dynamic programming states.
LeetCode 308: Range Sum Query 2D - Mutable
A clear explanation of Range Sum Query 2D - Mutable using a 2D Fenwick Tree for efficient updates and rectangle sum queries.
LeetCode 307: Range Sum Query - Mutable
A clear explanation of Range Sum Query - Mutable using a Fenwick Tree for efficient updates and range sums.
LeetCode 306: Additive Number
A clear explanation of Additive Number using split enumeration and deterministic checking.
LeetCode 305: Number of Islands II
A clear explanation of Number of Islands II using Union-Find to dynamically merge connected land cells.
LeetCode 304: Range Sum Query 2D - Immutable
A clear explanation of Range Sum Query 2D - Immutable using a 2D prefix sum matrix for constant-time rectangle queries.
LeetCode 303: Range Sum Query - Immutable
A clear explanation of Range Sum Query - Immutable using prefix sums for constant-time range queries.
LeetCode 302: Smallest Rectangle Enclosing Black Pixels
A clear explanation of Smallest Rectangle Enclosing Black Pixels using binary search on rows and columns.
LeetCode 301: Remove Invalid Parentheses
A clear explanation of Remove Invalid Parentheses using BFS to guarantee the minimum number of removals.
LeetCode 300: Longest Increasing Subsequence
A dynamic programming and patience sorting solution for finding the longest strictly increasing subsequence in an array.
LeetCode 299: Bulls and Cows
A counting solution for producing the Bulls and Cows hint while handling duplicate digits correctly.
LeetCode 298: Binary Tree Longest Consecutive Sequence
A DFS solution for finding the longest parent-to-child path where each node value increases by exactly one.
LeetCode 297: Serialize and Deserialize Binary Tree
A preorder DFS codec for converting a binary tree to a string and reconstructing the same tree from that string.
LeetCode 296: Best Meeting Point
A median-based solution for minimizing total Manhattan distance in a grid.
LeetCode 295: Find Median from Data Stream
A two-heap data structure for adding numbers from a stream and returning the current median in constant time.
LeetCode 294: Flip Game II
A recursive game theory solution with memoization for deciding whether the starting player can force a win.
LeetCode 293: Flip Game
A simple string scanning solution for generating every possible next state after flipping one consecutive ++ pair into --.
LeetCode 292: Nim Game
A game theory solution for deciding whether the first player can win by using the losing-position pattern of multiples of four.
LeetCode 291: Word Pattern II
A backtracking solution for matching a pattern string to a target string using a bijective character-to-substring mapping.
LeetCode 290: Word Pattern
A hash map solution for checking whether a pattern string and a space-separated word string form a bijection.
LeetCode 289: Game of Life
An in-place matrix simulation for computing the next state of Conway's Game of Life using temporary encoded states.
LeetCode 288: Unique Word Abbreviation
A hash map design for checking whether a word's abbreviation is unique in a dictionary.
LeetCode 287: Find the Duplicate Number
A Floyd cycle detection solution for finding the repeated number without modifying the array and using constant extra space.
LeetCode 286: Walls and Gates
A multi-source BFS solution for filling each empty room with its shortest distance to the nearest gate.
LeetCode 285: Inorder Successor in BST
A binary-search-style solution for finding the smallest node greater than p in a binary search tree.
LeetCode 284: Peeking Iterator
A wrapper iterator design that supports peeking at the next element without advancing the iterator.
LeetCode 283: Move Zeroes
A two-pointer in-place solution for moving all zeroes to the end while preserving the relative order of non-zero elements.
LeetCode 282: Expression Add Operators
A backtracking solution for inserting operators into a numeric string so the expression evaluates to a target value.
LeetCode 281: Zigzag Iterator
A queue-based iterator design for returning elements from two vectors in alternating order, with a clean extension to k vectors.
LeetCode 280: Wiggle Sort
A greedy in-place solution for rearranging an array into a non-strict wiggle pattern.
LeetCode 279: Perfect Squares
A dynamic programming solution for finding the least number of perfect square numbers that sum to n.
LeetCode 278: First Bad Version
A binary search solution for finding the first bad version while minimizing calls to the isBadVersion API.
LeetCode 277: Find the Celebrity
A two-pass solution for finding a celebrity using the knows API with O(n) calls and O(1) extra space.
LeetCode 276: Paint Fence
A dynamic programming solution for counting ways to paint fence posts with no more than two adjacent posts sharing the same color.
LeetCode 275: H-Index II
A clear explanation of the H-Index II problem using binary search on a sorted citations array.
LeetCode 274: H-Index
A clear explanation of the H-Index problem using sorting, then an optimized counting approach.
LeetCode 273: Integer to English Words
A clear explanation of the Integer to English Words problem using three-digit chunks and scale words.
LeetCode 272: Closest Binary Search Tree Value II
A clear explanation of the Closest Binary Search Tree Value II problem using inorder traversal and a fixed-size sliding window.
LeetCode 271: Encode and Decode Strings
A clear explanation of the Encode and Decode Strings problem using length-prefix encoding.
LeetCode 270: Closest Binary Search Tree Value
A clear explanation of the Closest Binary Search Tree Value problem using the BST property to walk toward the target.
LeetCode 269: Alien Dictionary
A clear explanation of the Alien Dictionary problem using graph construction and topological sorting.
LeetCode 268: Missing Number
A clear explanation of the Missing Number problem using sum formula and XOR.
LeetCode 267: Palindrome Permutation II
A clear explanation of the Palindrome Permutation II problem using character counts and backtracking over half of the palindrome.
LeetCode 266: Palindrome Permutation
A clear explanation of the Palindrome Permutation problem using character parity counting.
LeetCode 265: Paint House II
A clear explanation of the Paint House II problem using optimized dynamic programming with minimum and second minimum tracking.
LeetCode 264: Ugly Number II
A clear explanation of the Ugly Number II problem using dynamic programming with three pointers.
LeetCode 263: Ugly Number
A clear explanation of the Ugly Number problem using repeated division by the only allowed prime factors.
LeetCode 261: Graph Valid Tree
A clear explanation of the Graph Valid Tree problem using Union Find to detect cycles and verify connectivity.
LeetCode 260: Single Number III
A clear explanation of the Single Number III problem using XOR partitioning to isolate the two unique numbers.
LeetCode 259: 3Sum Smaller
A clear explanation of the 3Sum Smaller problem using sorting and the two-pointer technique.
LeetCode 258: Add Digits
A clear explanation of the Add Digits problem using repeated digit sums first, then the digital root formula.
LeetCode 257: Binary Tree Paths
A clear explanation of the Binary Tree Paths problem using DFS backtracking to collect every root-to-leaf path.
LeetCode 256: Paint House
A clear explanation of the Paint House problem using dynamic programming with constant space.
LeetCode 255: Verify Preorder Sequence in Binary Search Tree
A clear explanation of the Verify Preorder Sequence in Binary Search Tree problem using a monotonic stack and lower bound tracking.
LeetCode 254: Factor Combinations
A clear explanation of the Factor Combinations problem using DFS backtracking with non-decreasing factors.
LeetCode 253: Meeting Rooms II
A clear explanation of the Meeting Rooms II problem using a min heap to track active meeting end times.
LeetCode 252: Meeting Rooms
A clear explanation of the Meeting Rooms problem using interval sorting to detect overlaps.
LeetCode 251: Flatten 2D Vector
A clear explanation of the Flatten 2D Vector problem using row and column pointers to implement an iterator.
LeetCode 225: Implement Stack using Queues
A clear explanation of implementing a LIFO stack using only FIFO queue operations.
LeetCode 224: Basic Calculator
A clear explanation of evaluating an expression with plus, minus, spaces, and parentheses using a stack.
LeetCode 223: Rectangle Area
A clear explanation of computing the total covered area of two axis-aligned rectangles by subtracting their overlap.
LeetCode 222: Count Complete Tree Nodes
A clear explanation of counting nodes in a complete binary tree faster than visiting every node.
LeetCode 221: Maximal Square
A clear explanation of finding the largest square of 1s in a binary matrix using dynamic programming.
LeetCode 220: Contains Duplicate III
A clear explanation of checking nearby indices with nearby values using a sliding window and bucket hashing.
LeetCode 219: Contains Duplicate II
A clear explanation of detecting whether equal values appear within distance k using a hash map or sliding window set.
LeetCode 218: The Skyline Problem
A clear explanation of computing the skyline formed by buildings using sweep line and a max-heap.
LeetCode 217: Contains Duplicate
A clear explanation of detecting duplicates in an array using a hash set and sorting.
LeetCode 216: Combination Sum III
A clear explanation of finding k distinct numbers from 1 to 9 that sum to n using backtracking.
LeetCode 215: Kth Largest Element in an Array
A clear explanation of finding the kth largest element using sorting, a min-heap, and Quickselect.
LeetCode 214: Shortest Palindrome
A clear explanation of building the shortest palindrome by finding the longest palindromic prefix using KMP.
LeetCode 213: House Robber II
A clear explanation of maximizing robbed money from circularly arranged houses using dynamic programming.
LeetCode 212: Word Search II
A clear explanation of finding multiple words in a character board using a Trie and DFS backtracking.
LeetCode 211: Design Add and Search Words Data Structure
A clear explanation of designing a word dictionary with addWord and wildcard search using a Trie and DFS.
LeetCode 210: Course Schedule II
A clear explanation of finding a valid course ordering using topological sorting and cycle detection.
LeetCode 209: Minimum Size Subarray Sum
A clear explanation of finding the shortest contiguous subarray whose sum is at least target using a sliding window.
LeetCode 208: Implement Trie Prefix Tree
A clear explanation of implementing a Trie with insert, search, and startsWith operations.
LeetCode 207: Course Schedule
A clear explanation of detecting cycles in a prerequisite graph using topological sorting and DFS.
LeetCode 206: Reverse Linked List
A clear explanation of reversing a singly linked list using iterative and recursive approaches.
LeetCode 205: Isomorphic Strings
A clear explanation of checking whether two strings follow the same character mapping pattern.
LeetCode 204: Count Primes
A clear explanation of counting prime numbers less than n using the Sieve of Eratosthenes.
LeetCode 203: Remove Linked List Elements
A clear explanation of removing all linked list nodes with a target value using iteration and a dummy node.
LeetCode 202: Happy Number
A clear explanation of detecting whether repeated digit-square sums eventually reach 1.
LeetCode 201: Bitwise AND of Numbers Range
A clear explanation of finding the bitwise AND of every number in an inclusive range using the common binary prefix.
LeetCode 100: Same Tree
A detailed guide to solving Same Tree with recursive DFS and structural comparison.
LeetCode 99: Recover Binary Search Tree
A detailed guide to solving Recover Binary Search Tree with inorder traversal and two misplaced nodes.
LeetCode 98: Validate Binary Search Tree
A detailed guide to solving Validate Binary Search Tree with recursive lower and upper bounds.
LeetCode 97: Interleaving String
A detailed guide to solving Interleaving String with two-dimensional dynamic programming.
LeetCode 96: Unique Binary Search Trees
A detailed guide to solving Unique Binary Search Trees with dynamic programming and the Catalan recurrence.
LeetCode 95: Unique Binary Search Trees II
A detailed guide to solving Unique Binary Search Trees II with recursive tree generation over value ranges.
LeetCode 94: Binary Tree Inorder Traversal
A detailed guide to solving Binary Tree Inorder Traversal with recursion and an iterative stack.
LeetCode 93: Restore IP Addresses
A detailed guide to solving Restore IP Addresses with backtracking over four valid IP segments.
LeetCode 92: Reverse Linked List II
A detailed guide to solving Reverse Linked List II with a dummy node and in-place sublist reversal.
LeetCode 91: Decode Ways
A detailed guide to solving Decode Ways with dynamic programming and careful handling of zeroes.
LeetCode 90: Subsets II
A detailed guide to solving Subsets II with sorting, backtracking, and duplicate skipping.
LeetCode 89: Gray Code
A detailed guide to solving Gray Code using the binary-to-Gray-code formula.
LeetCode 88: Merge Sorted Array
A detailed guide to solving Merge Sorted Array in-place by merging from the back with three pointers.
LeetCode 87: Scramble String
A detailed guide to solving Scramble String with recursive dynamic programming and memoization.
LeetCode 86: Partition List
A detailed guide to solving Partition List with two dummy lists while preserving relative order.
LeetCode 85: Maximal Rectangle
A detailed guide to solving Maximal Rectangle by converting each matrix row into a histogram and applying a monotonic stack.
LeetCode 84: Largest Rectangle in Histogram
A detailed guide to solving Largest Rectangle in Histogram with a monotonic increasing stack.
LeetCode 83: Remove Duplicates from Sorted List
A detailed guide to solving Remove Duplicates from Sorted List with one pointer and in-place linked list rewiring.
LeetCode 82: Remove Duplicates from Sorted List II
A detailed guide to solving Remove Duplicates from Sorted List II with a dummy node and pointer rewiring.
LeetCode 81: Search in Rotated Sorted Array II
A detailed guide to solving Search in Rotated Sorted Array II with modified binary search and duplicate handling.
LeetCode 80: Remove Duplicates from Sorted Array II
A detailed guide to solving Remove Duplicates from Sorted Array II with an in-place two-pointer method.
LeetCode 79: Word Search
A detailed guide to solving Word Search with depth-first search and backtracking on a grid.
LeetCode 78: Subsets
A detailed guide to solving Subsets with backtracking and the include-or-skip recursion idea.
LeetCode 77: Combinations
A detailed guide to solving Combinations with backtracking and pruning.
LeetCode 76: Minimum Window Substring
A detailed guide to solving Minimum Window Substring with a sliding window and frequency counters.
LeetCode 200: Number of Islands
A clear explanation of counting connected groups of land cells in a grid using DFS or BFS.
LeetCode 199: Binary Tree Right Side View
A clear explanation of returning the visible nodes from the right side of a binary tree using level-order traversal.
LeetCode 198: House Robber
A clear explanation of maximizing robbery profit without robbing adjacent houses using dynamic programming.
LeetCode 191: Number of 1 Bits
A clear explanation of counting set bits in an integer using bit manipulation and Brian Kernighan's algorithm.
LeetCode 190: Reverse Bits
A clear explanation of reversing the bits of a 32-bit integer using bit manipulation.
LeetCode 189: Rotate Array
A clear explanation of rotating an array to the right by k steps using in-place reversal.
LeetCode 188: Best Time to Buy and Sell Stock IV
A clear explanation of maximizing stock trading profit with at most k transactions using dynamic programming.
LeetCode 187: Repeated DNA Sequences
A clear explanation of finding repeated 10-letter DNA substrings using a fixed-size sliding window and hash sets.
LeetCode 186: Reverse Words in a String II
A clear explanation of reversing the order of words in a character array in-place using two reversals.
LeetCode 179: Largest Number
A clear explanation of arranging non-negative integers to form the largest possible concatenated number using a custom sort order.
LeetCode 174: Dungeon Game
A clear explanation of computing the minimum initial health needed to survive a dungeon using reverse dynamic programming.
LeetCode 173: Binary Search Tree Iterator
A clear explanation of designing an iterator over a BST using controlled inorder traversal with a stack.
LeetCode 171: Excel Sheet Column Number
A clear explanation of converting an Excel column title into its numeric index using base 26 accumulation.
LeetCode 170: Two Sum III - Data Structure Design
A clear explanation of designing a data structure that supports add and find operations for pair sums.
LeetCode 169: Majority Element
A clear explanation of finding the element that appears more than half the time using Boyer-Moore voting.
LeetCode 168: Excel Sheet Column Title
A clear explanation of converting a positive integer into an Excel column title using bijective base 26.
LeetCode 167: Two Sum II - Input Array Is Sorted
A clear explanation of finding two numbers in a sorted array using two pointers and constant extra space.
LeetCode 166: Fraction to Recurring Decimal
A clear explanation of converting a fraction into decimal form and detecting repeating fractional parts with a hash map.
LeetCode 165: Compare Version Numbers
A clear explanation of comparing version strings revision by revision while ignoring leading zeros.
LeetCode 164: Maximum Gap
A clear explanation of finding the maximum adjacent gap in sorted order using buckets and the pigeonhole principle.
LeetCode 163: Missing Ranges
A clear explanation of finding all missing ranges inside an inclusive interval by scanning sorted unique numbers.
LeetCode 162: Find Peak Element
A clear explanation of finding any peak element using binary search on the slope of the array.
LeetCode 161: One Edit Distance
A clear explanation of checking whether two strings are exactly one edit apart using a linear scan.
LeetCode 160: Intersection of Two Linked Lists
A clear explanation of finding the node where two singly linked lists intersect using two pointers.
LeetCode 159: Longest Substring with At Most Two Distinct Characters
A clear explanation of finding the longest substring with at most two distinct characters using a sliding window.
LeetCode 158: Read N Characters Given read4 II - Call Multiple Times
A clear explanation of implementing read with read4 when read may be called multiple times.
LeetCode 157: Read N Characters Given Read4
A clear explanation of implementing read using the given read4 API and copying only the needed characters.
LeetCode 156: Binary Tree Upside Down
A clear explanation of flipping a binary tree upside down by rewiring pointers from the left spine.
LeetCode 155: Min Stack
A clear explanation of designing a stack that can return the current minimum element in constant time.
LeetCode 154: Find Minimum in Rotated Sorted Array II
A clear explanation of finding the minimum element in a rotated sorted array that may contain duplicates.
LeetCode 153: Find Minimum in Rotated Sorted Array
A clear explanation of finding the minimum element in a rotated sorted array using binary search.
LeetCode 152: Maximum Product Subarray
A detailed explanation of tracking both maximum and minimum products while scanning the array.
LeetCode 151: Reverse Words in a String
A clear explanation of reversing word order while removing extra spaces.
LeetCode 150: Evaluate Reverse Polish Notation
Evaluate an arithmetic expression written in Reverse Polish Notation using a stack.
LeetCode 149: Max Points on a Line
Find the maximum number of points lying on the same straight line using slope counting and normalization.
LeetCode 148: Sort List
Sort a singly linked list in ascending order using merge sort with fast and slow pointers.
LeetCode 147: Insertion Sort List
Sort a singly linked list using insertion sort by splicing each node into a growing sorted list.
LeetCode 146: LRU Cache
Design an LRU cache with O(1) get and put operations using a hash map and doubly linked list.
LeetCode 145: Binary Tree Postorder Traversal
Return the postorder traversal of a binary tree using recursion or an iterative stack-based approach.
LeetCode 144: Binary Tree Preorder Traversal
Return the preorder traversal of a binary tree using recursion or an explicit stack.
LeetCode 143: Reorder List
Reorder a singly linked list in-place by finding the middle, reversing the second half, and merging the two halves alternately.
LeetCode 142: Linked List Cycle II
Find the node where a linked list cycle begins using Floyd’s tortoise and hare algorithm with cycle entry mathematics.
LeetCode 141: Linked List Cycle
Detect whether a linked list contains a cycle using Floyd’s tortoise and hare two-pointer algorithm.
LeetCode 140: Word Break II
Return all valid sentences formed by inserting spaces into a string so every word belongs to the dictionary, using DFS with memoization.
LeetCode 139: Word Break
Decide whether a string can be segmented into dictionary words using dynamic programming over prefixes.
LeetCode 138: Copy List with Random Pointer
Create a deep copy of a linked list with next and random pointers using hash maps or interleaved node cloning.
LeetCode 137: Single Number II
Find the number that appears once when every other number appears three times using bit counting or finite-state bit manipulation.
LeetCode 136: Single Number
Find the only number that appears once using the XOR operator, while every other number appears exactly twice.
LeetCode 135: Candy
Compute the minimum candies needed using two greedy passes, one from the left and one from the right.
LeetCode 134: Gas Station
Find the unique starting gas station index using a greedy scan with total fuel balance and current tank balance.
LeetCode 133: Clone Graph
Create a deep copy of a connected undirected graph using DFS and a hash map from original nodes to cloned nodes.
LeetCode 132: Palindrome Partitioning II
Find the minimum number of cuts needed to split a string into palindromic substrings using palindrome precomputation and dynamic programming.
LeetCode 131: Palindrome Partitioning
Generate all ways to split a string so that every piece is a palindrome, using backtracking with palindrome precomputation.
LeetCode 130: Surrounded Regions
Capture surrounded O regions by marking border-connected O cells first, then flipping the remaining O cells.
LeetCode 129: Sum Root to Leaf Numbers
Compute the sum of all numbers formed by root-to-leaf paths using depth-first search and decimal accumulation.
LeetCode 128: Longest Consecutive Sequence
Find the longest run of consecutive integers in an unsorted array using a hash set and sequence-start detection.
LeetCode 127: Word Ladder
Use breadth-first search to find the shortest transformation sequence length between two words.
LeetCode 126: Word Ladder II
Find all shortest word transformation sequences using BFS to build shortest-path parents, then backtracking to reconstruct every answer.
LeetCode 125: Valid Palindrome
A clear explanation of checking whether a string is a palindrome after ignoring non-alphanumeric characters and case.
LeetCode 124: Binary Tree Maximum Path Sum
A clear explanation of finding the maximum path sum in a binary tree using bottom-up depth-first search.
LeetCode 123: Best Time to Buy and Sell Stock III
A clear explanation of maximizing stock profit with at most two transactions using dynamic programming.
LeetCode 122: Best Time to Buy and Sell Stock II
A clear explanation of maximizing stock profit with unlimited transactions using a greedy single-pass method.
LeetCode 121: Best Time to Buy and Sell Stock
A clear explanation of finding the maximum profit from one stock transaction using a single pass.
LeetCode 120: Triangle
A clear explanation of finding the minimum path sum in a triangle using bottom-up dynamic programming.
LeetCode 119: Pascal's Triangle II
A clear explanation of generating a single row of Pascal's Triangle using in-place dynamic programming.
LeetCode 118: Pascal's Triangle
A clear explanation of generating Pascal's Triangle row by row using dynamic programming.
LeetCode 117: Populating Next Right Pointers in Each Node II
A clear explanation of connecting next pointers in any binary tree using constant extra space.
LeetCode 116: Populating Next Right Pointers in Each Node
A clear explanation of connecting next pointers in a perfect binary tree using constant extra space.
LeetCode 115: Distinct Subsequences
A clear explanation of counting distinct subsequences using dynamic programming.
LeetCode 114: Flatten Binary Tree to Linked List
A clear explanation of flattening a binary tree into a linked list in preorder traversal order using recursive depth-first search.
LeetCode 113: Path Sum II
A clear explanation of finding all root-to-leaf paths whose values add up to a target sum using depth-first search and backtracking.
LeetCode 112: Path Sum
A clear explanation of checking whether a binary tree has a root-to-leaf path whose values add up to a target sum.
LeetCode 111: Minimum Depth of Binary Tree
A clear explanation of finding the minimum depth of a binary tree using breadth-first search.
LeetCode 110: Balanced Binary Tree
A clear explanation of checking whether a binary tree is height-balanced using bottom-up depth-first search.
LeetCode 109: Convert Sorted List to Binary Search Tree
A clear explanation of converting a sorted linked list into a height-balanced binary search tree using slow and fast pointers.
LeetCode 108: Convert Sorted Array to Binary Search Tree
A clear explanation of building a height-balanced binary search tree from a sorted array using divide and conquer.
LeetCode 107: Binary Tree Level Order Traversal II
A clear explanation of returning binary tree levels from bottom to top using breadth-first search.
LeetCode 106: Construct Binary Tree from Inorder and Postorder Traversal
A clear explanation of rebuilding a binary tree from inorder and postorder traversals using recursion and an index map.
LeetCode 105: Construct Binary Tree from Preorder and Inorder Traversal
A clear explanation of rebuilding a binary tree from preorder and inorder traversals using recursion and an index map.
LeetCode 104: Maximum Depth of Binary Tree
A clear explanation of finding the maximum depth of a binary tree using recursive depth-first search.
LeetCode 103: Binary Tree Zigzag Level Order Traversal
A clear explanation of zigzag level order traversal using breadth-first search and alternating level direction.
LeetCode 102: Binary Tree Level Order Traversal
A clear explanation of binary tree level order traversal using breadth-first search and a queue.
LeetCode 101: Symmetric Tree
A clear explanation of checking whether a binary tree is symmetric using mirror recursion.
LeetCode 75: Sort Colors
A clear guide to sorting an array of 0s, 1s, and 2s in place using the Dutch National Flag algorithm.
LeetCode 74: Search a 2D Matrix
A clear guide to searching a sorted 2D matrix using binary search over a virtual one-dimensional array.
LeetCode 73: Set Matrix Zeroes
A clear guide to setting matrix rows and columns to zero in place using the first row and first column as markers.
LeetCode 72: Edit Distance
A clear guide to computing the minimum number of insert, delete, and replace operations needed to convert one string into another.
LeetCode 71: Simplify Path
A clear guide to simplifying Unix-style file paths using a stack.
LeetCode 70: Climbing Stairs
A clear guide to counting distinct ways to climb stairs using dynamic programming.
LeetCode 69: Sqrt(x)
A clear guide to computing the integer square root using binary search without built-in exponent functions.
LeetCode 68: Text Justification
A clear guide to formatting text with greedy line packing and even space distribution.
LeetCode 67: Add Binary
A clear guide to adding two binary strings using two pointers and a carry.
LeetCode 66: Plus One
A clear guide to adding one to a large integer represented as an array of digits.
LeetCode 65: Valid Number
A clear guide to validating whether a string is a valid number using grammar rules and one left-to-right scan.
LeetCode 64: Minimum Path Sum
A clear guide to finding the minimum path sum in a grid using dynamic programming.
LeetCode 63: Unique Paths II
A clear guide to counting unique paths in a grid with obstacles using dynamic programming.
LeetCode 62: Unique Paths
A clear guide to counting unique paths in a grid using dynamic programming.
LeetCode 61: Rotate List
A clear guide to rotating a linked list to the right by k places using a circular list.
LeetCode 60: Permutation Sequence
A clear guide to finding the kth permutation sequence using factorial blocks instead of generating all permutations.
LeetCode 59: Spiral Matrix II
A clear guide to generating an n x n matrix filled from 1 to n squared in spiral order.
LeetCode 58: Length of Last Word
A clear guide to solving Length of Last Word by scanning the string from right to left.
LeetCode 57: Insert Interval
A clear guide to solving Insert Interval with one linear scan over sorted, non-overlapping intervals.
LeetCode 56: Merge Intervals
A clear guide to solving Merge Intervals by sorting intervals and merging them in one pass.
LeetCode 55: Jump Game
A clear guide to solving Jump Game with greedy reachability.
LeetCode 54: Spiral Matrix
A clear guide to reading a matrix in spiral order using shrinking boundaries.
LeetCode 53: Maximum Subarray
A clear guide to solving Maximum Subarray with brute force first, then Kadane's dynamic programming algorithm.
LeetCode 52: N-Queens II
A clear guide to solving N-Queens II by counting valid queen placements with backtracking.
LeetCode 51: N-Queens
A clear guide to solving N-Queens with backtracking, row-by-row placement, and constant-time conflict checks.
LeetCode 40: Combination Sum II
A clear explanation of finding unique combinations that sum to a target when each array element may be used at most once.
LeetCode 39: Combination Sum
A clear explanation of finding all unique combinations that sum to a target using backtracking.
LeetCode 38: Count and Say
A clear explanation of generating the count-and-say sequence using run-length encoding.
LeetCode 37: Sudoku Solver
A clear explanation of solving a Sudoku board using backtracking and constraint checking.
LeetCode 36: Valid Sudoku
A clear explanation of checking whether a partially filled Sudoku board is valid using hash sets.
LeetCode 35: Search Insert Position
A clear explanation of finding the index of a target, or where it should be inserted, using binary search.
LeetCode 34: Find First and Last Position of Element in Sorted Array
A clear explanation of finding the first and last index of a target in a sorted array using two binary searches.
LeetCode 33: Search in Rotated Sorted Array
A clear explanation of searching a rotated sorted array in logarithmic time using modified binary search.
LeetCode 32: Longest Valid Parentheses
A clear explanation of finding the longest well-formed parentheses substring using a stack of indices.
LeetCode 31: Next Permutation
A clear explanation of finding the next lexicographically greater permutation in place using a right-to-left scan.
LeetCode 30: Substring with Concatenation of All Words
A clear explanation of finding all starting indices where a substring is formed by concatenating every word exactly once.
LeetCode 29: Divide Two Integers
A clear explanation of integer division without using multiplication, division, or modulo, using repeated doubling with bit shifts.
LeetCode 28: Find the Index of the First Occurrence in a String
A clear explanation of finding the first occurrence of one string inside another using direct string matching.
LeetCode 27: Remove Element
A clear explanation of removing all occurrences of a value from an array in place using a write pointer.
LeetCode 26: Remove Duplicates from Sorted Array
A clear explanation of removing duplicates from a sorted array in place using two pointers.
LeetCode 25: Reverse Nodes in k-Group
A detailed explanation of reversing linked-list nodes in groups of k using pointer manipulation and constant extra space.
LeetCode 24: Swap Nodes in Pairs
A detailed explanation of swapping every two adjacent nodes in a linked list using pointer manipulation.
LeetCode 23: Merge k Sorted Lists
A detailed explanation of merging k sorted linked lists using a min heap.
LeetCode 22: Generate Parentheses
A detailed explanation of generating all well-formed parentheses strings using backtracking.
LeetCode 21: Merge Two Sorted Lists
A detailed explanation of merging two sorted linked lists using a dummy node and pointer splicing.
LeetCode 20: Valid Parentheses
A detailed explanation of checking whether a bracket string is valid using a stack.
LeetCode 19: Remove Nth Node From End of List
A detailed explanation of removing the nth node from the end of a singly linked list using two pointers and a dummy node.
LeetCode 18: 4Sum
A detailed explanation of finding all unique quadruplets that sum to a target using sorting and two pointers.
LeetCode 17: Letter Combinations of a Phone Number
A detailed explanation of generating all possible phone keypad letter combinations using backtracking.
LeetCode 16: 3Sum Closest
A detailed explanation of finding the sum of three integers closest to a target using sorting and two pointers.
LeetCode 15: 3Sum
A detailed explanation of finding all unique triplets that sum to zero using sorting and two pointers.
LeetCode 14: Longest Common Prefix
A detailed explanation of finding the longest common prefix among an array of strings by comparing characters column by column.
LeetCode 13: Roman to Integer
A detailed explanation of converting a Roman numeral string into an integer using symbol values and the subtraction rule.
LeetCode 12: Integer to Roman
A detailed explanation of converting an integer into a Roman numeral using a fixed value-symbol table and greedy subtraction.
LeetCode 11: Container With Most Water
A detailed explanation of finding the maximum water container area using two pointers.
LeetCode 10: Regular Expression Matching
A detailed explanation of matching a full string against a simplified regular expression with dot and star using dynamic programming.
LeetCode 9: Palindrome Number
A detailed explanation of checking whether an integer is a palindrome using digit operations without converting it to a string.
LeetCode 8: String to Integer (atoi)
A detailed explanation of parsing a string into a 32-bit signed integer with whitespace, sign, digit reading, and clamping rules.
LeetCode 7: Reverse Integer
A detailed explanation of reversing a signed 32-bit integer while handling overflow correctly.
LeetCode 6: Zigzag Conversion
A detailed explanation of converting a string into a zigzag pattern using row simulation.
LeetCode 5: Longest Palindromic Substring
A detailed explanation of finding the longest palindromic substring using expand-around-center.
LeetCode 4: Median of Two Sorted Arrays
A detailed explanation of finding the median of two sorted arrays using binary search over partitions.
LeetCode 3: Longest Substring Without Repeating Characters
A clear explanation of the longest substring problem using sliding window and a hash set.
LeetCode 2: Add Two Numbers
A detailed explanation of the Add Two Numbers linked list problem, including digit-by-digit addition, carry handling, and linked list construction.
LeetCode 1: Two Sum
A clear explanation of the Two Sum problem using brute force first, then an optimized hash map solution.
LeetCode 172: Factorial Trailing Zeroes
A clear explanation of counting trailing zeroes in n! by counting factors of 5 instead of computing the factorial directly.
LeetCode 185: Department Top Three Salaries
A clear SQL solution for finding employees whose salaries are in the top three unique salary levels within their department.
LeetCode 184: Department Highest Salary
A clear SQL solution for finding every employee who earns the highest salary in their department.
LeetCode 183: Customers Who Never Order
A clear SQL solution for finding customers who have no matching rows in the Orders table.
LeetCode 182: Duplicate Emails
A clear SQL solution for reporting email values that appear more than once in the Person table.
LeetCode 181: Employees Earning More Than Their Managers
A clear SQL solution for finding employees whose salary is greater than their manager's salary using a self join.
LeetCode 180: Consecutive Numbers
A clear SQL solution for finding numbers that appear at least three times consecutively in the Logs table.
LeetCode 178: Rank Scores
A clear SQL solution for ranking scores with dense ranking, where ties share the same rank and no rank numbers are skipped.
LeetCode 177: Nth Highest Salary
A clear SQL solution for finding the nth highest distinct salary from the Employee table.
LeetCode 176: Second Highest Salary
A clear SQL solution for finding the second highest distinct salary from the Employee table.