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