LeetCode 1099: Two Sum Less Than K
A clear explanation of finding the maximum sum of two numbers less than k using a two-pointer approach on a sorted array.
Tag
Array
431 notes
LeetCode 1095: Find in Mountain Array
A clear explanation of finding a target in a mountain array using three binary searches on the interface API.
LeetCode 1094: Car Pooling
A clear explanation of determining if a car can transport all passengers using a difference array for passenger count tracking.
LeetCode 1093: Statistics from a Large Sample
A clear explanation of computing statistical measures (minimum, maximum, mean, median, mode) from a frequency count array.
LeetCode 1091: Shortest Path in Binary Matrix
A clear explanation of finding the shortest path from top-left to bottom-right in a binary matrix using BFS.
LeetCode 1090: Largest Values From Labels
A clear explanation of selecting the maximum sum subset under item and label count constraints using a greedy approach.
LeetCode 1089: Duplicate Zeros
A clear explanation of duplicating zeros in-place in an array without using extra space by working backwards.
LeetCode 1086: High Five
A clear explanation of computing each student's top-5 average score using sorting and grouping.
LeetCode 1085: Sum of Digits in the Minimum Number
A clear explanation of checking if the digit sum of the array minimum is odd or even.
LeetCode 1074: Number of Submatrices That Sum to Target
A clear explanation of counting submatrices with a given sum using 2D prefix sums combined with the subarray sum equals k technique.
LeetCode 1073: Adding Negative Numbers
A clear explanation of adding two non-positive integers represented as arrays of digits.
LeetCode 1072: Flip Columns For Maximum Number of Equal Rows
A clear explanation of finding the maximum number of rows that can be made all-equal by flipping columns, using row pattern normalization.
LeetCode 1066: Campus Bikes II
A clear explanation of finding the minimum total Manhattan distance to assign bikes to workers using bitmask dynamic programming.
LeetCode 1064: Fixed Point
A clear explanation of finding the smallest index where arr[i] equals i using binary search on a sorted distinct array.
LeetCode 1063: Number of Valid Subarrays
A clear explanation of counting subarrays where the leftmost element is not larger than any other element, using a monotonic stack.
LeetCode 1060: Missing Element in Sorted Array
A clear explanation of finding the k-th missing number in a sorted array using binary search on the missing count.
LeetCode 1058: Minimize Rounding Error to Meet Target
A clear explanation of minimizing total rounding error when rounding prices to meet a target sum using a greedy approach.
LeetCode 1057: Campus Bikes
A clear explanation of greedily assigning bikes to workers based on Manhattan distance, prioritizing by distance then worker then bike index.
LeetCode 1054: Distant Barcodes
A clear explanation of rearranging barcodes so no two adjacent barcodes are equal using a greedy max-heap approach.
LeetCode 1053: Previous Permutation With One Swap
A clear explanation of finding the lexicographically largest permutation smaller than the given array using at most one swap.
LeetCode 1052: Grumpy Bookstore Owner
A clear explanation of maximizing satisfied customers by choosing the best window for the owner to not be grumpy using a sliding window.
LeetCode 1051: Height Checker
A clear explanation of counting students not in the expected height order by comparing the array to its sorted version.
LeetCode 1049: Last Stone Weight II
A clear explanation of minimizing the last stone weight by splitting stones into two groups using 0/1 knapsack dynamic programming.
LeetCode 1048: Longest String Chain
A clear explanation of finding the longest word chain where each word is formed by inserting one letter into the previous word, using dynamic programming.
LeetCode 1046: Last Stone Weight
A clear explanation of simulating stone smashing to find the last remaining weight using a max heap.
LeetCode 1043: Partition Array for Maximum Sum
A clear explanation of maximizing array sum by partitioning into subarrays of at most k elements, each filled with their maximum value, using dynamic programming.
LeetCode 1040: Moving Stones Until Consecutive II
A clear explanation of finding minimum and maximum moves to make stones consecutive using a sliding window.
LeetCode 1039: Minimum Score Triangulation of Polygon
A clear explanation of minimizing the total score of triangulating a polygon using interval dynamic programming.
LeetCode 1037: Valid Boomerang
A clear explanation of checking if three points form a boomerang (non-collinear) using the cross product.
LeetCode 1036: Escape a Large Maze
A clear explanation of determining if a source can reach a target in a very large grid with blocked cells using BFS with a cell count limit.
LeetCode 1035: Uncrossed Lines
A clear explanation of maximizing uncrossed connecting lines between two arrays using longest common subsequence dynamic programming.
LeetCode 1034: Coloring A Border
A clear explanation of coloring the border of a connected component in a grid using BFS.
LeetCode 1032: Stream of Characters
A clear explanation of efficiently querying a stream of characters against a word list using an Aho-Corasick trie.
LeetCode 1031: Maximum Sum of Two Non-Overlapping Subarrays
A clear explanation of finding two non-overlapping subarrays with maximum combined sum using prefix sums and running maximums.
LeetCode 1030: Matrix Cells in Distance Order
A clear explanation of sorting matrix cells by Chebyshev distance from a given center cell using BFS.
LeetCode 1029: Two City Scheduling
A clear explanation of minimizing total travel cost for two-city scheduling using a greedy refund approach after sending everyone to city A.
LeetCode 1027: Longest Arithmetic Subsequence
A clear explanation of finding the longest arithmetic subsequence in an array using dynamic programming with difference hash maps.
LeetCode 1024: Video Stitching
A clear explanation of finding the minimum number of video clips to cover a time range using a greedy interval covering approach.
LeetCode 1023: Camelcase Matching
A clear explanation of checking camelCase pattern matching by verifying uppercase consistency with a two-pointer approach.
LeetCode 1020: Number of Enclaves
A clear explanation of counting land cells unreachable from the grid border using BFS from boundary land cells.
LeetCode 1019: Next Greater Node In Linked List
A clear explanation of finding the next greater value for each node in a linked list using a monotonic stack.
LeetCode 1018: Binary Prefix Divisible By 5
A clear explanation of checking divisibility of binary prefixes by 5 using running remainder tracking.
LeetCode 1014: Best Sightseeing Pair
A clear explanation of maximizing the sightseeing score by tracking the best left value seen so far in a single pass.
LeetCode 1013: Partition Array Into Three Parts With Equal Sum
A clear explanation of checking if an array can be split into three contiguous parts with equal sum using a greedy two-pass approach.
LeetCode 1011: Capacity To Ship Packages Within D Days
A clear explanation of finding the minimum ship capacity to deliver all packages within D days using binary search.
LeetCode 1010: Pairs of Songs With Total Durations Divisible by 60
A clear explanation of counting song pairs whose total duration is divisible by 60 using remainder frequency counting.
LeetCode 1008: Construct Binary Search Tree from Preorder Traversal
A clear explanation of reconstructing a BST from its preorder traversal using value range bounds.
LeetCode 1007: Minimum Domino Rotations For Equal Row
A clear explanation of finding minimum rotations to make all tops or bottoms equal using a greedy candidate check.
LeetCode 1005: Maximize Sum Of Array After K Negations
A clear explanation of maximizing array sum after exactly k negations using a greedy strategy.
LeetCode 1004: Max Consecutive Ones III
A clear explanation of finding the longest subarray of ones by flipping at most k zeros using a sliding window.
LeetCode 1002: Find Common Characters
A clear explanation of finding characters that appear in all words using minimum frequency counts.
LeetCode 1001: Grid Illumination
A clear explanation of simulating lamp illumination on a grid using hash maps for rows, columns, and diagonals.
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 944: Delete Columns to Make Sorted
A clear explanation of solving Delete Columns to Make Sorted by checking each column independently.
LeetCode 918: Maximum Sum Circular Subarray
A clear explanation of finding the maximum circular subarray sum using Kadane's algorithm.
LeetCode 910: Smallest Range II
A clear explanation of minimizing the array range after adding either +k or -k to every element.
LeetCode 749: Contain Virus
Simulate virus containment by repeatedly quarantining the most dangerous infected region and spreading the remaining regions.
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 744: Find Smallest Letter Greater Than Target
Use binary search to find the smallest character strictly greater than the target with wraparound handling.
LeetCode 740: Delete and Earn
Transform the problem into House Robber dynamic programming by grouping equal values into total points.
LeetCode 731: My Calendar II
Allow double bookings but reject triple bookings using overlap interval tracking.
LeetCode 695: Max Area of Island
Find the largest connected island area in a binary grid using depth-first search.
LeetCode 682: Baseball Game
Simulate a baseball scoring system using a stack to process operations and compute the final score.
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 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 419: Battleships in a Board
A clear explanation of counting battleships in a board using one-pass observation without modifying the grid.
LeetCode 413: Arithmetic Slices
A clear explanation of counting arithmetic subarrays using dynamic programming and consecutive differences.
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 324: Wiggle Sort II
A clear explanation of Wiggle Sort II using sorting, median splitting, and virtual indexing.
LeetCode 322: Coin Change
A clear explanation of Coin Change using dynamic programming for minimum coin count.
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 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 265: Paint House II
A clear explanation of the Paint House II problem using optimized dynamic programming with minimum and second minimum tracking.
LeetCode 259: 3Sum Smaller
A clear explanation of the 3Sum Smaller problem using sorting and the two-pointer technique.
LeetCode 217: Contains Duplicate
A clear explanation of detecting duplicates in an array using a hash set and sorting.
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 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 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 969: Pancake Sorting
A clear explanation of sorting an array using prefix reversals by repeatedly placing the largest remaining value.
LeetCode 966: Vowel Spellchecker
A clear explanation of implementing a spellchecker with exact, case-insensitive, and vowel-error matching.
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 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 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 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 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 843: Guess the Word
A clear explanation of the Guess the Word interactive problem using candidate filtering and minimax-style guessing.
LeetCode 840: Magic Squares In Grid
A clear explanation of the Magic Squares In Grid problem using fixed-size subgrid validation.
LeetCode 835: Image Overlap
A clear explanation of the Image Overlap problem using translation vectors and frequency counting.
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 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 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 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 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 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 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 900: RLE Iterator
A clear explanation of designing an iterator over a run-length encoded sequence without expanding it.
LeetCode 898: Bitwise ORs of Subarrays
A clear explanation of counting distinct bitwise OR results from all non-empty subarrays using rolling sets.
LeetCode 896: Monotonic Array
A clear explanation of checking whether an array is monotonic using one pass and direction flags.
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 885: Spiral Matrix III
A clear explanation of generating grid coordinates in an outward clockwise spiral using simulation.
LeetCode 881: Boats to Save People
A clear explanation of minimizing rescue boats using sorting, greedy choice, and two pointers.
LeetCode 879: Profitable Schemes
A clear explanation of counting profitable crime schemes using 0/1 knapsack dynamic programming with members and profit states.
LeetCode 877: Stone Game
A clear explanation of the Stone Game problem using game theory and interval dynamic programming.
LeetCode 624: Maximum Distance in Arrays
A clear explanation of Maximum Distance in Arrays using sorted endpoints and a greedy scan.
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 249: Group Shifted Strings
A clear explanation of grouping strings by their shifting sequence using normalized hash keys.
LeetCode 247: Strobogrammatic Number II
A clear explanation of generating all strobogrammatic numbers of length n using recursion from the inside out.
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 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 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 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 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 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 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 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 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 867: Transpose Matrix
A clear explanation of transposing a matrix by swapping row and column indices.
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 860: Lemonade Change
A clear explanation of Lemonade Change using greedy simulation and bill counting.
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 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 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 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 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 939: Minimum Area Rectangle
A clear explanation of solving Minimum Area Rectangle using diagonal point pairs and constant-time point lookup.
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 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 825: Friends Of Appropriate Ages
A counting solution for computing how many directed friend requests are allowed by age rules.
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 817: Linked List Components
A hash set and linked list traversal solution for counting consecutive components whose values appear in nums.
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 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 804: Unique Morse Code Words
A set-based solution for counting how many different Morse code transformations appear among a list of words.
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 798: Smallest Rotation with Highest Score
A clear explanation of finding the smallest rotation with maximum score using a difference array.
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 786: K-th Smallest Prime Fraction
A clear explanation of finding the kth smallest fraction from a sorted array using a min-heap.
LeetCode 781: Rabbits in Forest
A clear explanation of finding the minimum possible number of rabbits using counting and greedy grouping.
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 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 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 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 755: Pour Water
A clear explanation of simulating water droplets over an elevation map by checking left first, then right.
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 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 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 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 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 750: Number Of Corner Rectangles
Count axis-aligned rectangles whose four corners are 1 using column-pair frequency counting.
LeetCode 746: Min Cost Climbing Stairs
Find the minimum cost to reach the top of the staircase using dynamic programming.
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 739: Daily Temperatures
Find how many days each temperature must wait for a warmer future day using a monotonic stack.
LeetCode 737: Sentence Similarity II
Check sentence similarity with transitive word relationships using union-find.
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 729: My Calendar I
Implement a calendar that accepts a booking only when it does not overlap with any existing booking.
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 694: Number of Distinct Islands
Count unique island shapes in a binary grid using DFS and relative coordinates.
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 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 679: 24 Game
Determine whether four numbers can be combined with arithmetic operations and parentheses to produce 24.
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 667: Beautiful Arrangement II
A clear explanation of constructing an array with exactly k distinct adjacent differences using a greedy pattern.
LeetCode 665: Non-decreasing Array
A clear explanation of checking whether an array can become non-decreasing by modifying at most one element.
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 656: Coin Path
A clear explanation of finding the minimum-cost path with bounded jumps, blocked cells, and lexicographic tie-breaking.
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 641: Design Circular Deque
An array-based circular buffer solution for implementing a fixed-size double-ended queue.
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 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 630: Course Schedule III
A greedy heap solution for taking the maximum number of courses before their deadlines.
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 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 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 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 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 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 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 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 587: Erect the Fence
A clear convex hull solution for returning all trees that lie on the fence boundary.
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 575: Distribute Candies
A clear explanation of Distribute Candies using a set to count candy types and a simple limit argument.
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 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 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 542: 01 Matrix
A clear explanation of computing the distance to the nearest zero in a binary matrix using multi-source BFS.
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 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 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 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 522: Longest Uncommon Subsequence II
A clear explanation of finding the longest uncommon subsequence among many strings using subsequence checks.
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 506: Relative Ranks
A clear explanation of assigning athlete ranks from scores using sorting while preserving original indices.
LeetCode 503: Next Greater Element II
A clear explanation of finding the next greater element in a circular array using a monotonic stack.
LeetCode 500: Keyboard Row
A clear explanation of filtering words that can be typed using only one row of an American keyboard.
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 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 491: Non-decreasing Subsequences
A clear explanation of generating all distinct non-decreasing subsequences using DFS, backtracking, and per-level duplicate control.
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 480: Sliding Window Median
A clear explanation of maintaining the median of each fixed-size window using two heaps and lazy deletion.
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 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 469: Convex Polygon
A clear explanation of checking whether ordered points form a convex polygon using cross products.
LeetCode 465: Optimal Account Balancing
A clear explanation of minimizing debt-settlement transactions using net balances, backtracking, and memoization-style pruning.
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 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 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 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 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 425: Word Squares
A clear explanation of building all word squares using backtracking with prefix pruning.
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 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 414: Third Maximum Number
A clear explanation of finding the third distinct maximum number using one pass and constant space.
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 406: Queue Reconstruction by Height
A clear explanation of reconstructing a queue using greedy sorting and indexed insertion.
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 396: Rotate Function
A clear explanation of maximizing the rotation function using a recurrence instead of simulating every rotation.
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 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 384: Shuffle an Array
A clear explanation of shuffling an array uniformly using the Fisher-Yates algorithm while supporting reset.
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 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 370: Range Addition
A clear explanation of applying many range updates efficiently using a difference array and prefix sums.
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 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 360: Sort Transformed Array
A clear explanation of sorting values after applying a quadratic function using two pointers.
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 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 330: Patching Array
A clear explanation of Patching Array using a greedy smallest-missing-sum invariant.
LeetCode 327: Count of Range Sum
A clear explanation of Count of Range Sum using prefix sums and merge sort counting.
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 321: Create Maximum Number
A clear explanation of Create Maximum Number using monotonic stacks for subsequences and greedy merging.
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 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 312: Burst Balloons
A clear explanation of Burst Balloons using interval dynamic programming and the last-burst idea.
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 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 300: Longest Increasing Subsequence
A dynamic programming and patience sorting solution for finding the longest strictly increasing subsequence in an array.
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 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 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 268: Missing Number
A clear explanation of the Missing Number problem using sum formula and XOR.
LeetCode 256: Paint House
A clear explanation of the Paint House problem using dynamic programming with constant space.
LeetCode 251: Flatten 2D Vector
A clear explanation of the Flatten 2D Vector problem using row and column pointers to implement an iterator.
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 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 213: House Robber II
A clear explanation of maximizing robbed money from circularly arranged houses using dynamic programming.
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 90: Subsets II
A detailed guide to solving Subsets II with sorting, backtracking, and duplicate skipping.
LeetCode 88: Merge Sorted Array
A detailed guide to solving Merge Sorted Array in-place by merging from the back with three pointers.
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 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 198: House Robber
A clear explanation of maximizing robbery profit without robbing adjacent houses using dynamic programming.
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 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 169: Majority Element
A clear explanation of finding the element that appears more than half the time using Boyer-Moore voting.
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 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 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 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 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 130: Surrounded Regions
Capture surrounded O regions by marking border-connected O cells first, then flipping the remaining O cells.
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 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 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 68: Text Justification
A clear guide to formatting text with greedy line packing and even space distribution.
LeetCode 66: Plus One
A clear guide to adding one to a large integer represented as an array of digits.
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 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 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 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 31: Next Permutation
A clear explanation of finding the next lexicographically greater permutation in place using a right-to-left scan.
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 18: 4Sum
A detailed explanation of finding all unique quadruplets that sum to a target using sorting and two pointers.
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 11: Container With Most Water
A detailed explanation of finding the maximum water container area using two pointers.
LeetCode 4: Median of Two Sorted Arrays
A detailed explanation of finding the median of two sorted arrays using binary search over partitions.
LeetCode 1: Two Sum
A clear explanation of the Two Sum problem using brute force first, then an optimized hash map solution.