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 1000, including A clear explanation of merging consecutive stone piles with minimum cost using interval dynamic programming.
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.