Thanks to visit codestin.com
Credit goes to tamnd.github.io

tag

#recursion

156 pages tagged

Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.3 Merge Sort Revisited

15.3 Merge Sort Revisited Problem You need to sort a collection of elements efficiently while preserving the relative order of equal values. The input may already be partially sorted, completely random, or adversarially arranged. Quadratic algorithms such as selection sort, insertion sort, and bubble sort become impractical as input size grows. For an array containing one million elements, an (O(n^2)) algorithm may require trillions of comparisons, while an (O(n \log...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.20 Complexity Analysis

15.20 Complexity Analysis Problem You have a divide-and-conquer algorithm and need to analyze its running time and memory usage. The code may look simple: solve(input) split input solve left solve right combine but the actual cost depends on several details: How many subproblems are created? How large are the subproblems? How expensive is the combine step? How deep is the recursion? How much auxiliary memory is allocated? Are subproblems balanced...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.6 Karatsuba Multiplication

15.6 Karatsuba Multiplication Problem You need to multiply very large integers. The numbers may contain hundreds, thousands, or millions of digits. The grade-school multiplication algorithm works, but it performs one multiplication for every pair of digits. For two (n)-digit numbers, that gives: $$ O(n^2) $$ single-digit multiplications. For small numbers, this is acceptable. For large integers used in symbolic computation, cryptography, computer algebra, or arbitrary-precision arithmetic, quadratic multiplication becomes expensive....
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.8 Fast Exponentiation

15.8 Fast Exponentiation Problem You need to compute: $$ x^n $$ where (n) is a nonnegative integer. The direct method multiplies (x) by itself (n) times: x * x * x * ... * x This takes: $$ O(n) $$ multiplications. For small exponents this is fine. For large exponents, especially in modular arithmetic, cryptography, combinatorics, and numerical code, linear exponentiation is too slow. Can divide and conquer reduce the...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.13 Median of Medians

15.13 Median of Medians Problem Quickselect finds the (k)-th smallest element in expected linear time. In practice, this is often sufficient. Random pivots work well, and the probability of repeatedly choosing poor pivots is low. However, some applications require stronger guarantees. Examples include: real-time systems adversarial inputs security-sensitive software theoretical algorithm analysis worst-case performance guarantees Can we design a selection algorithm that always runs in linear time, regardless of the...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.9 Divide-and-Conquer Dynamic Programming

15.9 Divide-and-Conquer Dynamic Programming Problem Many dynamic programming algorithms compute a table with the recurrence: $$ dp[i] = \min_{j < i} \left(dp[j] + cost(j,i)\right) $$ A direct implementation evaluates every possible transition. for i for j < i evaluate transition This requires: $$ O(n^2) $$ time. For (n=10^5), quadratic complexity is often too expensive. Even when the recurrence itself is simple, evaluating all possible transition points becomes the dominant cost....
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.16 Fast Fourier Transform

15.16 Fast Fourier Transform Problem You need to multiply two polynomials. Example: $$ A(x)=3+2x+5x^2 $$ $$ B(x)=1+4x $$ The product is: $$ C(x)=A(x)B(x) $$ A direct coefficient-by-coefficient multiplication compares every term of (A) with every term of (B). For two polynomials with (n) coefficients, this costs: $$ O(n^2) $$ That is acceptable for small inputs. It is too slow for large signals, big integer arithmetic, convolution, image processing, and many...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.19 Correctness Proofs

15.19 Correctness Proofs Problem A divide-and-conquer algorithm may look correct because its structure is simple: split solve recursively combine But many bugs hide in the boundaries: left half right half base case merge step pivot position strip condition A fast algorithm is not useful unless it computes the right result. How do we prove that a divide-and-conquer algorithm is correct? Solution Use induction on input size. Most divide-and-conquer correctness proofs...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.22 Common Bugs

15.22 Common Bugs Problem Divide-and-conquer algorithms often fail in ways that are difficult to see from the high-level design. The recurrence may be correct. The idea may be standard. The code may even work for ordinary examples. Then a small input breaks it: [] [1] [2, 1] [1, 1, 1] or a boundary case causes: infinite recursion missing element duplicate element wrong pivot position stack overflow incorrect count How do...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.11 Cache-Oblivious Algorithms

15.11 Cache-Oblivious Algorithms Problem An algorithm can have good asymptotic complexity and still run poorly on real hardware. Modern machines do not access all memory at the same speed. Data may live in registers, L1 cache, L2 cache, L3 cache, main memory, or disk. Moving data between these levels can cost more than arithmetic. A conventional algorithm often assumes this model: memory access costs O(1) Real machines behave more like...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.10 Parallel Divide and Conquer

15.10 Parallel Divide and Conquer Problem Divide-and-conquer algorithms naturally create independent subproblems. Merge sort sorts the left half and right half independently. Quick sort partitions the array and then recursively sorts both sides. Matrix multiplication splits work into independent block products. On a single core, these recursive calls run one after another. On modern hardware, this leaves available CPU cores idle. How can we turn recursive decomposition into parallel execution...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.14 Counting Inversions

15.14 Counting Inversions Problem You need to measure how far an array is from being sorted. Given an array: [2, 4, 1, 3, 5] an inversion is a pair of indexes: $$ i < j $$ such that: $$ a[i] > a[j] $$ In this array, the inversions are: (2, 1) (4, 1) (4, 3) So the inversion count is: 3 A sorted array has zero inversions. A reverse-sorted array...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.17 Offline Queries

15.17 Offline Queries Problem You need to answer many queries over a fixed dataset. Example: array = [5, 1, 7, 3, 9, 2] queries: count values <= 4 in range [1, 5] count values <= 6 in range [0, 3] count values <= 8 in range [2, 5] A direct approach handles each query independently. For each range, scan the relevant portion of the array. If there are (q) queries...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.23 Design Patterns

15.23 Design Patterns Problem After studying many divide-and-conquer algorithms, they can appear unrelated. Consider: Merge sort Quick sort Quickselect FFT Closest pair of points Karatsuba multiplication Strassen multiplication Binary search Inversion counting Offline query processing The details differ dramatically. Some work on arrays. Some work on geometry. Some work on algebra. Some work on answer spaces rather than data. How do experienced algorithm designers recognize when divide and conquer is...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.5 Closest Pair of Points

15.5 Closest Pair of Points Problem Given (n) points on a two-dimensional plane, find the pair of points whose Euclidean distance is minimal. For example: Point Coordinates A (2, 3) B (12, 30) C (40, 50) D (5, 1) E (12, 10) F (3, 4) The closest pair is: A(2,3) F(3,4) with distance: $$ \sqrt{(3-2)^2+(4-3)^2} $$ A straightforward solution compares every pair of points. With (n) points: $$ \binom{n}{2} =...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.15 Binary Search on Answer

15.15 Binary Search on Answer Problem Some problems ask for an optimal value rather than a specific object. Examples: What is the minimum machine speed needed to finish all jobs within 8 hours? What is the smallest capacity truck that can transport all packages in 5 days? What is the largest minimum distance possible between installed routers? What is the minimum time required for a group of workers to complete...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook ›

Chapter 15. Divide and Conquer

Chapter 15. Divide and Conquer
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.12 Selection Algorithms

15.12 Selection Algorithms Problem You need to find the (k)-th smallest element in an unsorted array. Examples: array = [9, 1, 6, 3, 8, 2, 7] k = 3 The 3rd smallest element is: 3 A simple solution is to sort the array and index into the sorted result. sort.Ints(nums) answer := nums[k-1] This works, but sorting does more work than necessary. Sorting gives the complete order: 1, 2, 3,...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.1 Recursion Trees

15.1 Recursion Trees Problem You are given a recursive algorithm and want to determine its time complexity. The implementation repeatedly divides a problem into smaller subproblems, performs some work at each level of recursion, and eventually reaches a base case. A recurrence such as $$ T(n) = 2T\left(\frac{n}{2}\right) + n $$ describes the running time, but the growth rate is not immediately obvious. How can you visualize the work performed...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.24 Case Studies

15.24 Case Studies Problem You have learned the mechanics of divide and conquer: split solve recursively combine But in real systems, problems rarely announce themselves as textbook recurrences. You may see a slow batch job, an expensive query engine, a data-processing task, or a geometric search problem. The challenge is recognizing which part of the work can be decomposed and which part must be combined carefully. How do divide-and-conquer techniques...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.21 Testing Divide-and-Conquer Algorithms

15.21 Testing Divide-and-Conquer Algorithms Problem Divide-and-conquer algorithms are prone to subtle implementation errors. The high-level idea may be correct, but bugs often appear in: base cases split boundaries merge logic pivot handling recursive termination index ranges temporary buffers These bugs may not appear on ordinary examples. A merge sort can pass random tests while failing on duplicates. A binary search can work for most inputs while looping forever on a...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.25 Exercises

15.25 Exercises Problem You have learned the main divide-and-conquer patterns in this chapter. To make the techniques usable, you need practice turning a problem statement into: split recursive solution combine proof complexity analysis tests This section gives a set of exercises designed to reinforce the chapter. Each exercise includes the intended pattern, expected complexity, and implementation hints. Treat these as recipes to complete, not as isolated puzzles. Exercise 1: Implement...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.7 Strassen Multiplication

15.7 Strassen Multiplication Problem Karatsuba's algorithm demonstrates that multiplication can be accelerated by reducing the number of recursive subproblems. The same question naturally arises for matrix multiplication. Given two (n \times n) matrices: $$ A $$ and $$ B $$ the classical algorithm computes: $$ C = AB $$ using three nested loops. For each element: $$ C_{ij} $$ we compute: $$ C_{ij}=\sum_{k=1}^{n}A_{ik}B_{kj} $$ The running time is: $$ O(n^3)...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.18 Closest Pair of Points

15.18 Closest Pair of Points Problem Given (n) points in a plane, find the pair with the smallest Euclidean distance. Example: (2,3) (12,30) (40,50) (5,1) (12,10) (3,4) The closest pair is: (2,3) (3,4) with distance: $$ \sqrt{(3-2)^2+(4-3)^2} = \sqrt{2} $$ A straightforward solution compares every pair of points. point 1 vs point 2 point 1 vs point 3 ... point n-1 vs point n The number of comparisons is: $$...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.4 Quick Sort Revisited

15.4 Quick Sort Revisited Problem Merge sort guarantees (O(n \log n)) performance and stable ordering, but it requires additional memory proportional to the input size. For large datasets, memory allocation and copying can become significant costs. Can we design a divide-and-conquer sorting algorithm that sorts data in place while maintaining excellent practical performance? Solution Use Quick Sort. Quick sort partitions an array around a selected pivot element. After partitioning, all...
algorithms divide-and-conquer recursion Jun 1, 2026
Programming › Algorithm Cookbook › Chapter 15. Divide and Conquer ›

15.2 Master Theorem

15.2 Master Theorem Problem Many divide-and-conquer algorithms produce recurrences of the form $$ T(n)=aT\left(\frac{n}{b}\right)+f(n) $$ where: (a) is the number of recursive subproblems. (n/b) is the size of each subproblem. (f(n)) is the non-recursive work performed at each call. For simple recurrences, recursion trees provide an intuitive solution. For larger algorithms, repeatedly constructing trees becomes tedious. Is there a systematic way to solve an entire class of divide-and-conquer recurrences? Solution...
algorithms divide-and-conquer recursion Jun 1, 2026
Practice › LeetCode › LeetCode 37xx ›

LeetCode 3782 - Last Remaining Integer After Alternating Deletion Operations

LeetCode Problem 3782 Difficulty: 🔴 Hard Topics: Math, Recursion Solution Before I write the full guide, I want to confirm one critical detail because the examples appear inconsistent with the stated operations. The statement says: Operation 1: Starting from the left, delete every second number Example transforms [1,2,3,4,5,6,7,8] → [1,3,5,7] This means it is deleting positions 2,4,6,8 and keeping odd positions . However, for Operation 2 on [1,3,5,7] , the...
leetcode Hard math recursion May 30, 2026
Practice › LeetCode › LeetCode 35xx ›

LeetCode 3566 - Partition Array into Two Equal Product Subsets

LeetCode Problem 3566 Difficulty: 🟡 Medium Topics: Array, Bit Manipulation, Recursion, Enumeration Solution Here’s a detailed technical solution guide for LeetCode 3566 following your formatting rules: Problem Understanding The problem asks us to determine whether a given array of distinct positive integers can be split into two non-empty, disjoint subsets , such that the product of the elements in each subset equals a given target value . Each element of...
leetcode Medium array bit-manipulation recursion enumeration May 30, 2026
Practice › LeetCode › LeetCode 35xx ›

LeetCode 3565 - Sequential Grid Path Cover

LeetCode Problem 3565 Difficulty: 🟡 Medium Topics: Array, Recursion, Matrix Solution Problem Understanding The problem asks us to find a path that visits every cell of a given m x n grid exactly once while visiting certain numbered cells in a specified order. Specifically, the grid contains integers from 1 to k in exactly one cell each, and the rest of the cells are zeros. The path can start at...
leetcode Medium array recursion matrix May 30, 2026
Practice › LeetCode › LeetCode 20xx ›

LeetCode 2094 - Finding 3-Digit Even Numbers

LeetCode Problem 2094 Difficulty: 🟢 Easy Topics: Array, Hash Table, Recursion, Sorting, Enumeration Solution Problem Understanding The problem gives us an array named digits , where every element is a single decimal digit from 0 to 9 . We must use exactly three elements from this array to build valid three digit integers. The important detail is that each digit can only be used as many times as it appears...
leetcode Easy array hash-table recursion sorting enumeration May 29, 2026
Practice › LeetCode › LeetCode 25xx ›

LeetCode 2550 - Count Collisions of Monkeys on a Polygon

LeetCode Problem 2550 Difficulty: 🟡 Medium Topics: Math, Recursion Solution Problem Understanding In this problem, we have a regular polygon with n vertices, and each vertex initially contains exactly one monkey. Every monkey must move simultaneously to one of its two neighboring vertices. Since each monkey has only two choices, clockwise or counterclockwise, the total number of possible movement configurations is 2^n . A collision occurs in two situations. The...
leetcode Medium math recursion May 29, 2026
Practice › LeetCode › LeetCode 33xx ›

LeetCode 3304 - Find the K-th Character in String Game I

LeetCode Problem 3304 Difficulty: 🟢 Easy Topics: Math, Bit Manipulation, Recursion, Simulation Solution Problem Understanding The problem defines an infinite string-building process that starts with the string "a" . At every operation, we take the current string and create a transformed version where every character is replaced by the next character in the alphabet. Then we append this transformed string to the original string. For example: "a" becomes "ab" "ab"...
leetcode Easy math bit-manipulation recursion simulation May 29, 2026
Practice › LeetCode › LeetCode 24xx ›

LeetCode 2487 - Remove Nodes From Linked List

LeetCode Problem 2487 Difficulty: 🟡 Medium Topics: Linked List, Stack, Recursion, Monotonic Stack Solution Problem Understanding The problem gives us the head of a singly linked list and asks us to remove every node that has a strictly greater value somewhere to its right. In other words, for each node, we must determine whether there exists another node later in the list whose value is larger. If such a node...
leetcode Medium linked-list stack recursion monotonic-stack May 29, 2026
Practice › LeetCode › LeetCode 18xx ›

LeetCode 1808 - Maximize Number of Nice Divisors

LeetCode Problem 1808 Difficulty: 🔴 Hard Topics: Math, Recursion, Number Theory Solution Problem Understanding The problem gives us an integer primeFactors , representing the maximum total number of prime factors we are allowed to use when constructing some positive integer n . The goal is not to maximize n itself. Instead, we want to maximize the number of "nice divisors" of n . A divisor of n is considered nice...
leetcode Hard math recursion number-theory May 29, 2026
Practice › LeetCode › LeetCode 19xx ›

LeetCode 1969 - Minimum Non-Zero Product of the Array Elements

LeetCode Problem 1969 Difficulty: 🟡 Medium Topics: Math, Greedy, Recursion Solution LeetCode 1969, Minimum Non-Zero Product of the Array Elements Problem Understanding The problem gives us an integer p and defines an array containing every number from 1 to 2^p - 1 . Each number is represented in binary using exactly p bits. We are allowed to repeatedly perform a special operation. In one operation, we choose two numbers and...
leetcode Medium math greedy recursion May 29, 2026
Practice › LeetCode › LeetCode 33xx ›

LeetCode 3307 - Find the K-th Character in String Game II

LeetCode Problem 3307 Difficulty: 🔴 Hard Topics: Math, Bit Manipulation, Recursion Solution Problem Understanding The problem describes a string manipulation game between Alice and Bob. Initially, Alice starts with a string word = "a" . Bob provides a list of operations, represented by the integer array operations . Each operation transforms word in a specific way: If operations[i] == 0 , Alice duplicates the current string by appending a copy...
leetcode Hard math bit-manipulation recursion May 29, 2026
Practice › LeetCode › LeetCode 19xx ›

LeetCode 1922 - Count Good Numbers

LeetCode Problem 1922 Difficulty: 🟡 Medium Topics: Math, Recursion Solution LeetCode 1922, Count Good Numbers Problem Understanding The problem asks us to count how many digit strings of length n satisfy a specific positional rule. A digit string is considered "good" when: Every digit placed at an even index, meaning indices 0, 2, 4, ... , must itself be an even digit. Every digit placed at an odd index, meaning...
leetcode Medium math recursion May 29, 2026
Practice › LeetCode › LeetCode 07xx ›

LeetCode 776 - Split BST

LeetCode Problem 776 Difficulty: 🟡 Medium Topics: Tree, Binary Search Tree, Recursion, Binary Tree Solution Problem Understanding The problem asks us to split a binary search tree (BST) into two separate subtrees based on a target value. Specifically, the first subtree should contain all nodes with values less than or equal to the target, and the second subtree should contain all nodes with values strictly greater than the target. Importantly,...
leetcode Medium tree binary-search-tree recursion binary-tree May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 241 - Different Ways to Add Parentheses

LeetCode Problem 241 Difficulty: 🟡 Medium Topics: Math, String, Dynamic Programming, Recursion, Memoization Solution Problem Understanding The problem gives us a mathematical expression as a string containing integers and arithmetic operators ( + , - , * ). We are asked to compute all possible results that can be obtained by inserting parentheses in every valid way. The key detail is that we are not evaluating the expression using normal...
leetcode Medium math string dynamic-programming recursion memoization May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 44 - Wildcard Matching

LeetCode Problem 44 Difficulty: 🔴 Hard Topics: String, Dynamic Programming, Greedy, Recursion Solution Problem Understanding This problem asks us to determine whether an entire input string s matches a wildcard pattern p . The pattern supports two special wildcard characters: '?' matches exactly one character. '*' matches any sequence of characters, including an empty sequence. The important detail is that the match must cover the entire string. Partial matches are...
leetcode Hard string dynamic-programming greedy recursion May 28, 2026
Practice › LeetCode › LeetCode 01xx ›

LeetCode 143 - Reorder List

LeetCode Problem 143 Difficulty: 🟡 Medium Topics: Linked List, Two Pointers, Stack, Recursion Solution Problem Understanding The problem gives us the head of a singly linked list and asks us to reorder the nodes in a very specific alternating pattern. A normal linked list looks like this: L0 → L1 → L2 → ... → Ln We must transform it into: L0 → Ln → L1 → Ln-1 → L2...
leetcode Medium linked-list two-pointers stack recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 234 - Palindrome Linked List

LeetCode Problem 234 Difficulty: 🟢 Easy Topics: Linked List, Two Pointers, Stack, Recursion Solution Problem Understanding The problem gives us the head of a singly linked list and asks whether the sequence of values stored in the list forms a palindrome. A palindrome is a sequence that reads the same forward and backward. For example, the array [1,2,2,1] is a palindrome because reversing it produces the same sequence. On the...
leetcode Easy linked-list two-pointers stack recursion May 28, 2026
Practice › LeetCode › LeetCode 07xx ›

LeetCode 779 - K-th Symbol in Grammar

LeetCode Problem 779 Difficulty: 🟡 Medium Topics: Math, Bit Manipulation, Recursion Solution Problem Understanding The problem defines a special binary grammar sequence that grows row by row. The first row contains only a single value: 0 Every later row is generated from the previous one using these rules: Replace every 0 with 01 Replace every 1 with 10 This means the rows evolve like this: Row 1: 0 Row 2:...
leetcode Medium math bit-manipulation recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 233 - Number of Digit One

LeetCode Problem 233 Difficulty: 🔴 Hard Topics: Math, Dynamic Programming, Recursion Solution LeetCode 233 - Number of Digit One Problem Statement Given a non-negative integer n , we must count how many times the digit 1 appears in every number from 0 through n , inclusive. The important detail is that we are not counting how many numbers contain the digit 1 . Instead, we are counting the total number...
leetcode Hard math dynamic-programming recursion May 28, 2026
Practice › LeetCode › LeetCode 18xx ›

LeetCode 1823 - Find the Winner of the Circular Game

LeetCode Problem 1823 Difficulty: 🟡 Medium Topics: Array, Math, Recursion, Queue, Simulation Solution Problem Understanding The problem describes a variation of the classic Josephus problem. We have n friends sitting in a circle, numbered 1 through n clockwise. Starting from the first friend, we count k friends clockwise (inclusive of the starting friend). The friend at the k -th position is removed from the circle. The counting then resumes from...
leetcode Medium array math recursion queue simulation May 28, 2026
Practice › LeetCode › LeetCode 03xx ›

LeetCode 390 - Elimination Game

LeetCode Problem 390 Difficulty: 🟡 Medium Topics: Math, Recursion Solution Problem Understanding The problem gives us a sorted list containing every integer from 1 to n . We repeatedly eliminate numbers in alternating directions until only one number remains. The elimination process works like this: In the first pass, we move from left to right and remove the first number and every other number after that. In the second pass,...
leetcode Medium math recursion May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 21 - Merge Two Sorted Lists

LeetCode Problem 21 Difficulty: 🟢 Easy Topics: Linked List, Recursion Solution Problem Understanding This problem asks us to merge two already sorted singly linked lists into one new sorted linked list. The important detail is that we are not creating entirely new nodes for the merged result. Instead, we reuse the existing nodes by reconnecting their next pointers. Each input list is sorted in non-decreasing order. That means values can...
leetcode Easy linked-list recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 247 - Strobogrammatic Number II

LeetCode Problem 247 Difficulty: 🟡 Medium Topics: Array, String, Recursion Solution Problem Understanding The problem asks us to generate every strobogrammatic number of a given length n . A strobogrammatic number is a number that still appears valid after being rotated 180 degrees. Not every digit works under rotation. Only the following digit mappings are valid: Original Rotated 0 0 1 1 6 9 8 8 9 6 For example,...
leetcode Medium array string recursion May 28, 2026
Practice › LeetCode › LeetCode 03xx ›

LeetCode 326 - Power of Three

LeetCode Problem 326 Difficulty: 🟢 Easy Topics: Math, Recursion Solution LeetCode 326 - Power of Three Problem Understanding The problem asks us to determine whether a given integer n can be represented as a power of three. In mathematical terms, we need to check whether there exists an integer x such that: $$n = 3^x$$ A power of three sequence looks like this: $$1, 3, 9, 27, 81, 243, \dots$$...
leetcode Easy math recursion May 28, 2026
Practice › LeetCode › LeetCode 08xx ›

LeetCode 894 - All Possible Full Binary Trees

LeetCode Problem 894 Difficulty: 🟡 Medium Topics: Dynamic Programming, Tree, Recursion, Memoization, Binary Tree Solution Problem Understanding The problem asks us to generate every possible full binary tree that contains exactly n nodes. A full binary tree is a special kind of binary tree where every node has either exactly two children or no children at all. In other words, a node can never have only one child. The input...
leetcode Medium dynamic-programming tree recursion memoization binary-tree May 28, 2026
Practice › LeetCode › LeetCode 03xx ›

LeetCode 394 - Decode String

LeetCode Problem 394 Difficulty: 🟡 Medium Topics: String, Stack, Recursion Solution LeetCode 394 - Decode String Problem Understanding The problem gives us a string that contains encoded patterns of the form k[encoded_string] . The integer k tells us how many times the substring inside the brackets should be repeated. Our task is to fully decode the string and return the expanded result. For example, the input: 3[a] means the string...
leetcode Medium string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 255 - Verify Preorder Sequence in Binary Search Tree

LeetCode Problem 255 Difficulty: 🟡 Medium Topics: Array, Stack, Tree, Binary Search Tree, Recursion, Monotonic Stack, Binary Tree Solution Problem Understanding The problem gives an array of unique integers called preorder . This array is supposed to represent the preorder traversal of a binary search tree, and we must determine whether such a BST could actually exist. In a preorder traversal, nodes are visited in this order: Visit the current...
leetcode Medium array stack tree binary-search-tree recursion monotonic-stack binary-tree May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 25 - Reverse Nodes in k-Group

LeetCode Problem 25 Difficulty: 🔴 Hard Topics: Linked List, Recursion Solution Problem Understanding This problem asks us to reverse a singly linked list in groups of size k . Instead of reversing the entire list at once, we only reverse consecutive chunks containing exactly k nodes. For example, if the linked list is: 1 -> 2 -> 3 -> 4 -> 5 and k = 2 , we reverse every...
leetcode Hard linked-list recursion May 28, 2026
Practice › LeetCode › LeetCode 05xx ›

LeetCode 509 - Fibonacci Number

LeetCode Problem 509 Difficulty: 🟢 Easy Topics: Math, Dynamic Programming, Recursion, Memoization Solution Problem Understanding This problem asks us to compute the n th Fibonacci number. The Fibonacci sequence is defined recursively. The first two numbers are fixed: F(0) = 0 F(1) = 1 Every value after that is calculated as the sum of the previous two values: F(n) = F(n - 1) + F(n - 2) Given an integer...
leetcode Easy math dynamic-programming recursion memoization May 28, 2026
Practice › LeetCode › LeetCode 04xx ›

LeetCode 439 - Ternary Expression Parser

LeetCode Problem 439 Difficulty: 🟡 Medium Topics: String, Stack, Recursion Solution Problem Understanding The problem gives us a string representing a nested ternary expression and asks us to evaluate it. A ternary expression follows the familiar format: condition ? value_if_true : value_if_false The condition is always either 'T' or 'F' . If the condition is 'T' , the expression evaluates to the value before the ':' . If the condition...
leetcode Medium string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 273 - Integer to English Words

LeetCode Problem 273 Difficulty: 🔴 Hard Topics: Math, String, Recursion Solution Problem Understanding The problem asks us to convert a non-negative integer into its English words representation. Instead of returning digits such as 12345 , we must produce a properly formatted English phrase such as "Twelve Thousand Three Hundred Forty Five" . The input is a single integer num where: 0 <= num <= 2^31 - 1 The maximum possible...
leetcode Hard math string recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 224 - Basic Calculator

LeetCode Problem 224 Difficulty: 🔴 Hard Topics: Math, String, Stack, Recursion Solution Problem Understanding The problem gives us a string representing a mathematical expression containing integers, addition, subtraction, parentheses, and spaces. Our task is to evaluate the expression and return the final integer result. The expression is guaranteed to be valid. That guarantee is extremely important because it simplifies parsing. We do not need to worry about malformed parentheses, invalid...
leetcode Hard math string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 11xx ›

LeetCode 1106 - Parsing A Boolean Expression

LeetCode Problem 1106 Difficulty: 🔴 Hard Topics: String, Stack, Recursion Solution Problem Understanding The problem asks us to evaluate a boolean expression represented as a string . The expression can contain the literals 't' and 'f' for true and false, as well as three types of operators: logical NOT '!' , logical AND '&' , and logical OR '|' . Each operator has a specific syntax: '!(subExpr)' negates a sub-expression,...
leetcode Hard string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 50 - Pow(x, n)

LeetCode Problem 50 Difficulty: 🟡 Medium Topics: Math, Recursion Solution Problem Understanding The problem asks us to implement exponentiation manually, specifically computing: $$x^n$$ where x is a floating point number and n is an integer exponent. The input consists of two values: x , the base n , the exponent The output should be the result of raising x to the power n . A few examples clarify the behavior:...
leetcode Medium math recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 231 - Power of Two

LeetCode Problem 231 Difficulty: 🟢 Easy Topics: Math, Bit Manipulation, Recursion Solution Problem Understanding The problem asks us to determine whether a given integer n is a power of two. A number is considered a power of two if it can be written in the form: $$n = 2^x$$ where x is a non-negative integer. Some examples of powers of two are: 1 = 2^0 2 = 2^1 4 =...
leetcode Easy math bit-manipulation recursion May 28, 2026
Practice › LeetCode › LeetCode 07xx ›

LeetCode 770 - Basic Calculator IV

LeetCode Problem 770 Difficulty: 🔴 Hard Topics: Hash Table, Math, String, Stack, Recursion Solution Problem Understanding The problem requires parsing and evaluating a mathematical expression that includes integers, variables, addition, subtraction, multiplication, and parentheses, while also applying a substitution map for certain variables. Essentially, we are building a symbolic algebra engine that simplifies expressions according to standard arithmetic rules. The input consists of a string expression that may contain integers,...
leetcode Hard hash-table math string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 10 - Regular Expression Matching

LeetCode Problem 10 Difficulty: 🔴 Hard Topics: String, Dynamic Programming, Recursion Solution Problem Understanding LeetCode 10, Regular Expression Matching, asks us to determine whether an entire input string s matches a pattern p . The pattern supports two special regular expression characters: . matches any single character * matches zero or more occurrences of the character immediately before it The important detail is that the match must cover the entire...
leetcode Hard string dynamic-programming recursion May 28, 2026
Practice › LeetCode › LeetCode 04xx ›

LeetCode 486 - Predict the Winner

LeetCode Problem 486 Difficulty: 🟡 Medium Topics: Array, Math, Dynamic Programming, Recursion, Game Theory Solution Problem Understanding The problem describes a two-player game played on an integer array. Players alternate turns, and during each turn a player may only take a number from one of the two ends of the array. The chosen value is added to that player's score, and the element is removed from the array. The game...
leetcode Medium array math dynamic-programming recursion game-theory May 28, 2026
Practice › LeetCode › LeetCode 03xx ›

LeetCode 342 - Power of Four

LeetCode Problem 342 Difficulty: 🟢 Easy Topics: Math, Bit Manipulation, Recursion Solution LeetCode 342 - Power of Four Problem Understanding This problem asks us to determine whether a given integer n is an exact power of four. In other words, we need to check whether there exists some integer x such that: n = 4^x Examples of powers of four are: 1 = 4^0 4 = 4^1 16 = 4^2...
leetcode Easy math bit-manipulation recursion May 28, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 248 - Strobogrammatic Number III

LeetCode Problem 248 Difficulty: 🔴 Hard Topics: Array, String, Recursion Solution Problem Understanding The problem asks us to count how many numbers within the inclusive range [low, high] are strobogrammatic. A strobogrammatic number is a number that appears unchanged when rotated 180 degrees. Only certain digits remain valid after rotation: Original Rotated 0 0 1 1 6 9 8 8 9 6 For example, "69" becomes "96" after rotation, but...
leetcode Hard array string recursion May 28, 2026
Practice › LeetCode › LeetCode 16xx ›

LeetCode 1611 - Minimum One Bit Operations to Make Integers Zero

LeetCode Problem 1611 Difficulty: 🔴 Hard Topics: Math, Dynamic Programming, Bit Manipulation, Recursion, Memoization Solution Problem Understanding This problem asks us to transform a given integer n into 0 using a specialized set of bit-flipping operations. Each operation allows you to flip either the rightmost bit of the binary representation of n , or the i-th bit if the (i-1)-th bit is set to 1 and all lower bits (i-2...
leetcode Hard math dynamic-programming bit-manipulation recursion memoization May 28, 2026
Practice › LeetCode › LeetCode 05xx ›

LeetCode 544 - Output Contest Matches

LeetCode Problem 544 Difficulty: 🟡 Medium Topics: String, Recursion, Simulation Solution Problem Understanding The problem asks us to simulate the structure of a playoff tournament bracket. We are given n teams, numbered from 1 to n , where smaller numbers represent stronger teams. The tournament pairing rule is fixed: in every round, the strongest remaining team must play against the weakest remaining team. The output is not the winner of...
leetcode Medium string recursion simulation May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 24 - Swap Nodes in Pairs

LeetCode Problem 24 Difficulty: 🟡 Medium Topics: Linked List, Recursion Solution Problem Understanding The problem gives us the head of a singly linked list and asks us to swap every pair of adjacent nodes. The important detail is that we are not allowed to modify the values stored inside the nodes. We must physically rearrange the node connections by changing pointers. For example, if the linked list is: 1 ->...
leetcode Medium linked-list recursion May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 60 - Permutation Sequence

LeetCode Problem 60 Difficulty: 🔴 Hard Topics: Math, Recursion Solution LeetCode 60, Permutation Sequence Problem Understanding The problem gives us the numbers from 1 to n , and asks us to find the kth permutation when all possible permutations are ordered lexicographically. For example, when n = 3 , the numbers are: [1, 2, 3] All permutations in sorted order are: 123 132 213 231 312 321 If k =...
leetcode Hard math recursion May 28, 2026
Practice › LeetCode › LeetCode 12xx ›

LeetCode 1265 - Print Immutable Linked List in Reverse

LeetCode Problem 1265 Difficulty: 🟡 Medium Topics: Linked List, Two Pointers, Stack, Recursion Solution Problem Understanding This problem gives us a special type of linked list called an immutable linked list. Unlike a normal linked list problem, we are not allowed to access node fields directly. Instead, we can only interact with the list through two provided APIs: printValue() , which prints the current node's value getNext() , which returns...
leetcode Medium linked-list two-pointers stack recursion May 28, 2026
Practice › LeetCode › LeetCode 07xx ›

LeetCode 736 - Parse Lisp Expression

LeetCode Problem 736 Difficulty: 🔴 Hard Topics: Hash Table, String, Stack, Recursion Solution Problem Understanding The problem asks us to evaluate a Lisp-like expression represented as a string. The expression can contain integers, variables, and three special operations: let , add , and mult . An expression evaluates to a single integer value. The challenge is not arithmetic itself, but correctly handling nested scopes and variable shadowing. A let expression...
leetcode Hard hash-table string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 07xx ›

LeetCode 772 - Basic Calculator III

LeetCode Problem 772 Difficulty: 🔴 Hard Topics: Math, String, Stack, Recursion Solution LeetCode 772 - Basic Calculator III Problem Understanding This problem asks us to evaluate a mathematical expression represented as a string. The expression may contain: Non-negative integers Addition ( + ) Subtraction ( - ) Multiplication ( * ) Division ( / ) Parentheses ( ( and ) ) The goal is to compute the final integer result...
leetcode Hard math string stack recursion May 28, 2026
Practice › LeetCode › LeetCode 15xx ›

LeetCode 1545 - Find Kth Bit in Nth Binary String

LeetCode Problem 1545 Difficulty: 🟡 Medium Topics: String, Recursion, Simulation Solution Problem Understanding The problem defines a recursively constructed binary string sequence: S1 = "0" Si = Si-1 + "1" + reverse(invert(Si-1)) For every new level, we take the previous string, append "1" , then append the reversed and bit-inverted version of the previous string. The task is to return the kth bit in the string Sn . To understand...
leetcode Medium string recursion simulation May 28, 2026
Practice › LeetCode › LeetCode 00xx ›

LeetCode 2 - Add Two Numbers

LeetCode Problem 2 Difficulty: 🟡 Medium Topics: Linked List, Math, Recursion Solution Add Two Numbers Problem Understanding The problem gives us two non empty singly linked lists. Each linked list represents a non negative integer, but the digits are stored in reverse order. That means the head node contains the least significant digit. For example: [2,4,3] represents the number 342 [5,6,4] represents the number 465 The task is to add...
leetcode Medium linked-list math recursion May 27, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 203 - Remove Linked List Elements

LeetCode Problem 203 Difficulty: 🟢 Easy Topics: Linked List, Recursion Solution Problem Understanding The problem asks us to remove every node from a singly linked list whose value is equal to a given integer val . After all matching nodes are removed, we must return the head of the modified linked list. A linked list is a linear data structure where each node stores a value and a reference to...
leetcode Easy linked-list recursion May 27, 2026
Practice › LeetCode › LeetCode 02xx ›

LeetCode 206 - Reverse Linked List

LeetCode Problem 206 Difficulty: 🟢 Easy Topics: Linked List, Recursion Solution Problem Understanding The problem asks us to reverse a singly linked list. A singly linked list is a sequence of nodes where each node stores a value and a pointer to the next node in the sequence. The input, head , represents the first node of the linked list. Our task is to rearrange the connections between the nodes...
leetcode Easy linked-list recursion May 27, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 09xx ›

LeetCode 998: Maximum Binary Tree II

Problem Restatement We are given the root of a maximum binary tree and an integer val . The tree was originally built from an array a using this rule: The largest value in a becomes the root. The left subtree is built from the elements to the left of that largest value. The right subtree is built from the elements to the right of that largest value. Now we append...
leetcode tree binary-tree recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 09xx ›

LeetCode 965: Univalued Binary Tree

Problem Restatement We are given the root of a binary tree. A binary tree is univalued if every node in the tree has the same value. Return true if every node has the same value. Otherwise, return false . The official constraints say the tree has between 1 and 100 nodes, and each node value is in the range [0, 99] . Input and Output Item Meaning Input root ,...
leetcode tree binary-tree depth-first-search recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 08xx ›

LeetCode 894: All Possible Full Binary Trees

Problem Restatement We are given an integer n . Return a list of all possible full binary trees with exactly n nodes. A full binary tree is a binary tree where every node has either: Children count Meaning 0 Leaf node 2 Internal node No node may have exactly one child. Each node has value 0 . We only care about the tree shapes. LeetCode asks for all possible full...
leetcode dynamic-programming recursion tree binary-tree memoization May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 772: Basic Calculator III

Problem Restatement We are given a valid arithmetic expression string s . The expression may contain: non-negative integers + - * / ( ) spaces We need to evaluate the expression and return the integer result. The expression follows normal arithmetic rules: Parentheses are evaluated first. Multiplication and division happen before addition and subtraction. Operators with the same precedence are evaluated from left to right. Integer division truncates toward zero....
leetcode string stack recursion parser May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 50: Pow(x, n)

Problem Restatement We need to implement pow(x, n) . Given a floating-point number x and an integer n , return x raised to the power n . The official problem asks us to calculate x raised to n , written as x^n . Example inputs include x = 2.00000, n = 10 , which returns 1024.00000 , and x = 2.00000, n = -2 , which returns 0.25000 . For...
leetcode math recursion binary-exponentiation May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 250: Count Univalue Subtrees

Problem Restatement We are given the root of a binary tree. Return the number of uni-value subtrees. A uni-value subtree means every node in that subtree has the same value. An empty tree has 0 uni-value subtrees. The constraints say the tree has between 0 and 1000 nodes, and each node value is between -1000 and 1000 . Input and Output Item Meaning Input Root of a binary tree Output...
leetcode binary-tree dfs recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 770: Basic Calculator IV

Problem Restatement We are given an algebraic expression as a string. The expression may contain: integers variables + - * parentheses We are also given some variable values through: evalvars evalints For example: evalvars = ["e"] evalints = [1] means: e = 1 We need to simplify the expression after substituting known variables. The result should be returned as a list of string terms. The official format requires variable factors...
leetcode string stack recursion hash-table math May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 248: Strobogrammatic Number III

Problem Restatement We are given two strings, low and high , representing two integers. Return the number of strobogrammatic numbers in the inclusive range: low <= num <= high A strobogrammatic number looks the same after being rotated 180 degrees. The numbers are represented as strings because the range can be large. The constraints say 1 <= low.length, high.length <= 15 , low and high contain only digits, low <=...
leetcode recursion string dfs May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 247: Strobogrammatic Number II

Problem Restatement We are given an integer n . Return all strobogrammatic numbers of length n . A strobogrammatic number is a number that looks the same after being rotated 180 degrees. The answer may be returned in any order. The constraint is 1 <= n <= 14 . The valid rotated digit pairs are: Left Digit Right Digit 0 0 1 1 6 9 8 8 9 6 But...
leetcode recursion array string May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 08xx ›

LeetCode 865: Smallest Subtree with all the Deepest Nodes

Problem Restatement We are given the root of a binary tree. The depth of a node is its shortest distance from the root. A deepest node is a node with the largest depth in the whole tree. We need to return the smallest subtree that contains all deepest nodes. Since a subtree is represented by its root node, we return the root of that smallest subtree. Another way to say...
leetcode tree binary-tree dfs recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 08xx ›

LeetCode 814: Binary Tree Pruning

Problem Restatement We are given the root of a binary tree. Every node has value either 0 or 1 . We need to remove every subtree that does not contain a 1 . A subtree means a node together with all of its descendants. If a subtree has only 0 values, that entire subtree should be removed. Return the root of the pruned tree. The official problem asks us to...
leetcode binary-tree dfs recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 761: Special Binary String

Problem Restatement A special binary string is a binary string with two properties: It has the same number of 1 s and 0 s. Every prefix has at least as many 1 s as 0 s. We are given a special binary string s . One move lets us choose two consecutive non-empty special substrings and swap them. We need to return the lexicographically largest string possible after applying any...
leetcode string recursion divide-and-conquer sorting May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 736: Parse Lisp Expression

Problem Restatement We are given a string expression that represents a Lisp-like expression. We need to evaluate it and return its integer value. An expression can be one of these forms: Form Meaning Integer A positive or negative integer Variable A name whose value comes from a surrounding let add Adds two expressions mult Multiplies two expressions let Assigns variables, then evaluates a final expression The official syntax includes integer...
leetcode string recursion hash-table parsing May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 784: Letter Case Permutation

Problem Restatement We are given a string s . Each alphabet letter may be changed independently to lowercase or uppercase. Digits must stay the same. Return all possible strings we can create. The output may be returned in any order. Input and Output Item Meaning Input A string s Output A list of all possible letter-case permutations Letters Can become lowercase or uppercase Digits Must stay unchanged Constraint 1 <=...
leetcode string backtracking dfs recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 669: Trim a Binary Search Tree

Problem Restatement We are given the root of a binary search tree and two boundaries: Variable Meaning low Lowest allowed node value high Highest allowed node value We need to trim the tree so that every remaining node value lies inside: [low, high] The relative structure of the remaining nodes must stay the same. If one remaining node was a descendant of another remaining node before trimming, it should still...
leetcode tree binary-tree binary-search-tree depth-first-search recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 687: Longest Univalue Path

Problem Restatement We are given the root of a binary tree. We need to return the length of the longest path where every node on the path has the same value. The path may or may not pass through the root. The length of a path is counted by number of edges, not number of nodes. The official constraints allow an empty tree, up to 10^4 nodes, node values from...
leetcode tree binary-tree dfs recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 617: Merge Two Binary Trees

Problem Restatement We are given two binary trees: root1 and root2 . We need to merge them into a single binary tree. The merge rule is: Case Result Both nodes exist Sum their values One node is null Use the non-null node Both null Result is null We return the merged tree as the new root. The official problem defines merging two binary trees by summing overlapping nodes and using...
leetcode tree binary-tree recursion dfs May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 779: K-th Symbol in Grammar

Problem Restatement We build a table of rows. The first row is: 0 To build the next row, every symbol is replaced: Symbol Becomes 0 01 1 10 So the first few rows are: row 1: 0 row 2: 01 row 3: 0110 row 4: 01101001 Given integers n and k , return the k -th symbol in row n . The position k is 1-indexed. Input and Output Item...
leetcode recursion math bit-manipulation May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 631: Design Excel Sum Formula

Problem Restatement We need to design a simplified Excel spreadsheet. The spreadsheet has: Item Meaning height Number of rows width Last column letter, from A to Z Initial value Every cell starts as 0 We need to support three operations: Operation Meaning set(row, column, val) Set a cell to a fixed integer value get(row, column) Return the current value of a cell sum(row, column, numbers) Set a cell to a...
leetcode design matrix hash-map recursion May 12, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 606: Construct String from Binary Tree

Problem Restatement We are given the root of a binary tree. We need to convert the tree into a string using preorder traversal: Step Meaning Visit current node Output node value Visit left subtree Wrap in parentheses Visit right subtree Wrap in parentheses However, unnecessary empty parentheses should be omitted. There is one important exception: If a node has a right child but no left child, we must include: ()...
leetcode tree binary-tree recursion string May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 572: Subtree of Another Tree

Problem Restatement We are given the roots of two binary trees: Name Meaning root The larger tree subRoot The tree we want to find inside root Return True if there is a subtree of root that has exactly the same structure and node values as subRoot . A subtree means a node and all of its descendants. A tree is also considered a subtree of itself. The official constraints say...
leetcode tree binary-tree depth-first-search recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 546: Remove Boxes

Problem Restatement We are given an array boxes . Each integer represents the color of one box. In one move, we can remove a continuous group of boxes with the same color. If the group has k boxes, we gain: k * k points. After removing boxes, the remaining boxes close the gap. We repeat this until no boxes remain. We need to return the maximum score possible. The official...
leetcode dynamic-programming interval-dp memoization recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 544: Output Contest Matches

Problem Restatement We are given n teams labeled from 1 to n . Team 1 is the strongest team. Team n is the weakest team. In each round, we pair the strongest remaining team with the weakest remaining team, the second strongest with the second weakest, and so on. We need to return the final tournament bracket as a string. Pairs are written using parentheses and commas: (a,b) The input...
leetcode string simulation recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 543: Diameter of Binary Tree

Problem Restatement We are given the root of a binary tree. We need to return the length of the tree's diameter. The diameter is the length of the longest path between any two nodes in the tree. This path may or may not pass through the root. The length is measured by the number of edges, not the number of nodes. For example, in root = [1,2,3,4,5] , one longest...
leetcode tree binary-tree depth-first-search recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 590: N-ary Tree Postorder Traversal

Problem Restatement We are given the root of an N-ary tree. An N-ary tree is a tree where each node may have any number of children. We need to return the postorder traversal of the tree's node values. In postorder traversal, we visit: All children from left to right. The current node after its children. The input may be empty. If the tree has no nodes, return an empty list....
leetcode tree dfs stack recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 509: Fibonacci Number

Problem Restatement The Fibonacci sequence is defined as: F(0) = 0 F(1) = 1 For all n > 1 : $$ F(n)=F(n-1)+F(n-2) $$ We are given an integer n . We need to return the value of F(n) . The official problem asks us to compute the n th Fibonacci number using the standard recurrence definition. Input and Output Item Meaning Input An integer n Output The n th Fibonacci...
leetcode dynamic-programming math recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 655: Print Binary Tree

Problem Restatement We are given the root of a binary tree. We need to return a 2D string matrix that represents the tree in a formatted layout. The layout follows fixed rules: Rule Meaning Rows One row for each tree level Columns Enough columns to center every subtree Root placement The root goes in the middle of the first row Child placement Children are placed one row below their parent...
leetcode tree binary-tree depth-first-search recursion matrix May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 589: N-ary Tree Preorder Traversal

Problem Restatement We are given the root of an N-ary tree. An N-ary tree is a tree where each node can have any number of children. We need to return the preorder traversal of the tree's node values. In preorder traversal, we visit: The current node. Its children from left to right. The number of nodes is in the range [0, 10^4] , node values are between 0 and 10^4...
leetcode tree dfs stack recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 06xx ›

LeetCode 654: Maximum Binary Tree

Problem Restatement We are given an array of distinct integers called nums . We must construct a binary tree using the following rules: The root is the maximum number in the array. The left subtree is built recursively from the elements to the left of the maximum number. The right subtree is built recursively from the elements to the right of the maximum number. Return the root of the constructed...
leetcode tree binary-tree divide-and-conquer recursion monotonic-stack May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 09xx ›

LeetCode 951: Flip Equivalent Binary Trees

Problem Restatement We are given the roots of two binary trees, root1 and root2 . A flip operation chooses one node and swaps its left and right child subtrees. Two trees are flip equivalent if we can make them equal after doing zero or more flip operations. Return true if the two trees are flip equivalent. Otherwise, return false . The official constraints say each tree has between 0 and...
leetcode tree binary-tree dfs recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 776: Split BST

Problem Restatement We are given the root of a binary search tree and an integer target . We need to split the tree into two separate binary search trees: Tree Contains First tree All nodes with values <= target Second tree All nodes with values > target The tree may not contain a node whose value is exactly target . We should preserve the original parent-child relationships as much as...
leetcode tree binary-search-tree recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 07xx ›

LeetCode 701: Insert into a Binary Search Tree

Problem Restatement We are given the root of a binary search tree and a value val . We need to insert val into the tree while keeping the binary search tree property valid. A binary search tree has this rule: Position Rule Left subtree Values are smaller than the current node Right subtree Values are greater than the current node The problem guarantees that val does not already exist in...
leetcode binary-tree binary-search-tree recursion tree May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 536: Construct Binary Tree from String

Problem Restatement We are given a string representing a binary tree. The string format is: node(left_subtree)(right_subtree) Each node starts with an integer value. If a node has children, the left subtree appears first inside parentheses. The right subtree appears second inside another pair of parentheses. We need to reconstruct the binary tree and return its root. The string may contain negative integers. Input and Output Item Meaning Input A string...
leetcode tree binary-tree recursion string parsing May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 05xx ›

LeetCode 558: Logical OR of Two Binary Grids Represented as Quad-Trees

Problem Restatement We are given two quad-trees representing two binary grids. Each grid cell contains either: Value Meaning 0 False 1 True We need to compute the logical OR of the two grids and return the result as a quad-tree. The logical OR rule is: A B A OR B 0 0 0 0 1 1 1 0 1 1 1 1 Each quad-tree node contains: Field Meaning val Boolean...
leetcode tree quad-tree recursion May 11, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 04xx ›

LeetCode 450: Delete Node in a BST

Problem Restatement We are given the root of a binary search tree and an integer key . We need to delete the node whose value equals key . After deletion, the tree must still be a valid binary search tree. Return the possibly updated root of the tree. The root can change. For example, if we delete the original root, some other node may become the new root. The official...
leetcode tree binary-search-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 03xx ›

LeetCode 397: Integer Replacement

Problem Restatement We are given a positive integer n . We need to turn n into 1 using the fewest operations. The allowed operations are: Case Operation n is even Replace n with n / 2 n is odd Replace n with either n + 1 or n - 1 Return the minimum number of operations needed. For example: n = 8 The best path is: 8 -> 4 ->...
leetcode math bit-manipulation greedy recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 03xx ›

LeetCode 372: Super Pow

Problem Restatement We are given: Variable Meaning a Positive integer base b Very large exponent represented as an array of digits We need to compute: a^b mod 1337 The exponent can be extremely large, so we cannot convert the entire digit array into a normal integer directly. The problem statement defines: b = [1, 2, 3] as the exponent: 123 The modulus is always: 1337 The official examples include: a...
leetcode math modular-arithmetic recursion fast-power May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 03xx ›

LeetCode 394: Decode String

Problem Restatement We are given an encoded string s . The encoding rule is: k[encoded_string] This means encoded_string should be repeated exactly k times. For example: "3[a]" -> "aaa" "2[bc]" -> "bcbc" The encoding may be nested: "3[a2[c]]" -> "accaccacc" The input is guaranteed to be valid. Brackets are well-formed, repeat counts are positive integers, and digits only appear as repeat counts. The decoded output length will not exceed 10^5...
leetcode string stack recursion parser May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 222: Count Complete Tree Nodes

Problem Restatement We are given the root of a complete binary tree. We need to return the number of nodes in the tree. A complete binary tree has this shape: Rule Meaning Every level except possibly the last Completely filled Last level Filled from left to right Missing nodes Can only appear at the far right of the last level The official problem asks for an algorithm that runs in...
leetcode binary-tree recursion binary-search May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 03xx ›

LeetCode 390: Elimination Game

Problem Restatement We start with a sorted list of integers: [1, 2, 3, ..., n] Then we repeatedly remove numbers until only one number remains. The removal process alternates direction: From left to right, remove the first number and every other number after it. From right to left, remove the rightmost number and every other number before it. Keep alternating directions. Return the last remaining number. For example, when n...
leetcode math recursion simulation May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 273: Integer to English Words

Problem Restatement We are given a non-negative integer num . Return its English words representation. Examples: 123 -> "One Hundred Twenty Three" 12345 -> "Twelve Thousand Three Hundred Forty Five" 1234567 -> "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven" 0 -> "Zero" The constraint is: 0 <= num <= 2^31 - 1 So the largest possible number is less than 2.15 billion. We only need scale...
leetcode math string recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 241: Different Ways to Add Parentheses

Problem Restatement We are given a string expression containing: Non-negative integers Operators: + - * We need to compute all possible results from adding parentheses in every valid way. The answer may contain duplicate values if different parenthesizations produce the same result. LeetCode examples include: Input: expression = "2-1-1" Output: [0,2] and: Input: expression = "2*3-4*5" Output: [-34,-14,-10,-10,10] The expression length is at most 20 . Input and Output Item...
leetcode divide-and-conquer recursion memoization expression-parsing May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 98: Validate Binary Search Tree

Problem Restatement We are given the root of a binary tree. We need to return whether the tree is a valid binary search tree. A valid binary search tree has three rules: Rule Meaning Left subtree Every node must be strictly less than the current node Right subtree Every node must be strictly greater than the current node Recursive rule Both left and right subtrees must also be valid BSTs...
leetcode tree binary-search-tree depth-first-search recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 95: Unique Binary Search Trees II

Problem Restatement We are given an integer n . We need to generate all structurally unique binary search trees that contain exactly the values: 1, 2, 3, ..., n Each value must be used exactly once. The answer may be returned in any order. A binary search tree has this rule: Node relation Required value rule Left subtree Values smaller than the root Right subtree Values greater than the root...
leetcode tree binary-search-tree dynamic-programming backtracking recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 94: Binary Tree Inorder Traversal

Problem Restatement We are given the root of a binary tree. We need to return the inorder traversal of the tree's node values. Inorder traversal means: left subtree current node right subtree The official constraints say the number of nodes is between 0 and 100 , and each node value is between -100 and 100 . The follow-up asks for an iterative solution. Input and Output Item Meaning Input Root...
leetcode binary-tree depth-first-search stack recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 114: Flatten Binary Tree to Linked List

Problem Restatement We are given the root of a binary tree. We need to flatten the tree into a linked list in-place. The linked list must follow the same order as preorder traversal: root -> left -> right After flattening: Every node's left child must become None . Every node's right child points to the next node in preorder order. The official problem specifically requires the flattened structure to use...
leetcode tree binary-tree linked-list dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 113: Path Sum II

Problem Restatement We are given the root of a binary tree and an integer targetSum . We need to return all root-to-leaf paths where the sum of node values equals targetSum . Each returned path must: Start at the root. End at a leaf. Have node values summing to targetSum . The official problem asks for all root-to-leaf paths whose sum equals the target. For this tree: 5 / \...
leetcode tree binary-tree dfs backtracking recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 112: Path Sum

Problem Restatement We are given the root of a binary tree and an integer targetSum . We need to return True if the tree has at least one root-to-leaf path whose node values add up to targetSum . A leaf is a node with no children. If no such path exists, return False . The official problem uses this same root-to-leaf path requirement. For this tree: 5 / \ 4...
leetcode tree binary-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 110: Balanced Binary Tree

Problem Restatement We are given the root of a binary tree. We need to determine whether the tree is height-balanced. A binary tree is height-balanced when the left and right subtrees of every node differ in height by no more than 1 . The official problem asks us to return true if the tree is balanced, otherwise false . For this tree: 3 / \ 9 20 / \ 15...
leetcode tree binary-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 87: Scramble String

Problem Restatement We are given two strings: s1: str s2: str Both strings have the same length. We need to return whether s2 can be produced by scrambling s1 . A scramble is formed recursively: If the string length is 1 , stop. Otherwise, split the string into two non-empty parts. Either keep the two parts in the same order or swap them. Apply the same process recursively to each...
leetcode string dynamic-programming recursion memoization May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 108: Convert Sorted Array to Binary Search Tree

Problem Restatement We are given a sorted integer array nums in ascending order. We need to convert it into a height-balanced binary search tree. The official problem defines a height-balanced binary tree as a binary tree in which the depth difference between the two subtrees of every node is never more than 1 . The tree must also satisfy the binary search tree property: left subtree values < root value...
leetcode tree binary-search-tree dfs recursion divide-and-conquer May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 236: Lowest Common Ancestor of a Binary Tree

Problem Restatement We are given: The root of a binary tree Two nodes p and q We need to return their lowest common ancestor. The lowest common ancestor is the lowest node in the tree that has both p and q as descendants. A node can be a descendant of itself. Unlike LeetCode 235, this tree is a normal binary tree, not a binary search tree. So we cannot use...
leetcode tree binary-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 04xx ›

LeetCode 486: Predict the Winner

Problem Restatement We are given an integer array nums . Two players play a game with this array. Player 1 moves first. On each turn, the current player must take one number from either end of the array. That means the player may take either the leftmost number or the rightmost number. The chosen number is added to that player's score, and the number is removed from the array. Both...
leetcode array dynamic-programming game-theory recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 03xx ›

LeetCode 339: Nested List Weight Sum

Problem Restatement We are given a nested list of integers called nestedList . Each element is either: Type Meaning Integer A single number List A nested list that may contain integers or more lists The depth of an integer is the number of lists it is inside. Return the sum of every integer multiplied by its depth. The problem examples include [[1,1],2,[1,1]] -> 10 , [1,[4,[6]]] -> 27 , and...
leetcode depth-first-search breadth-first-search recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 282: Expression Add Operators

Problem Restatement We are given: A string num containing only digits. An integer target . We need to insert the operators: +, -, * between the digits so that the final mathematical expression evaluates exactly to target . We must return all valid expressions. Digits must remain in the original order. We may also choose to join consecutive digits into a larger number. For example: "123" can become: "1+2+3" "12-3"...
leetcode backtracking dfs string recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 60: Permutation Sequence

Problem Restatement We are given two integers, n and k . The set is: [1, 2, 3, ..., n] This set has n! unique permutations. If we list all permutations in sorted order, we need to return the k th permutation as a string. The official constraints are 1 <= n <= 9 and 1 <= k <= n! . Input and Output Item Meaning Input Two integers n and...
leetcode math recursion permutation May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 234: Palindrome Linked List

Problem Restatement We are given the head of a singly linked list. We need to return True if the linked list is a palindrome, and False otherwise. A palindrome reads the same forward and backward. For example: [1, 2, 2, 1] is a palindrome. But: [1, 2] is not a palindrome. LeetCode examples include head = [1,2,2,1] , which returns true , and head = [1,2] , which returns false...
leetcode linked-list two-pointers recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 106: Construct Binary Tree from Inorder and Postorder Traversal

Problem Restatement We are given two integer arrays: inorder postorder Both arrays describe the same binary tree. inorder is the inorder traversal of the tree. postorder is the postorder traversal of the same tree. We need to construct and return the original binary tree. The values are unique, and both arrays are guaranteed to describe the same tree. The official constraints also say each value in postorder appears in inorder...
leetcode tree binary-tree dfs recursion hash-map divide-and-conquer May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 206: Reverse Linked List

Problem Restatement We are given the head of a singly linked list. We need to reverse the list and return the new head. Example: 1 -> 2 -> 3 -> 4 -> 5 becomes: 5 -> 4 -> 3 -> 2 -> 1 The official statement says: given the head of a singly linked list, reverse the list, and return the reversed list. Input and Output Item Meaning Input Head...
leetcode linked-list recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 25: Reverse Nodes in k-Group

Problem Restatement We are given the head of a linked list and an integer k . We need to reverse the nodes of the list k at a time and return the modified list. If the number of remaining nodes at the end is fewer than k , those nodes must stay in the same order. We may not change node values. We may only change node links. For example:...
leetcode linked-list recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 24: Swap Nodes in Pairs

Problem Restatement We are given the head of a linked list. We need to swap every two adjacent nodes and return the modified list head. We are not allowed to modify node values. We must change the actual node links. For example: 1 -> 2 -> 3 -> 4 becomes: 2 -> 1 -> 4 -> 3 The problem statement explicitly requires changing nodes themselves instead of only swapping values....
leetcode linked-list recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 105: Construct Binary Tree from Preorder and Inorder Traversal

Problem Restatement We are given two integer arrays: preorder inorder Both arrays describe the same binary tree. preorder is the preorder traversal of the tree. inorder is the inorder traversal of the same tree. We need to construct and return the original binary tree. The official problem states that preorder and inorder are traversals of the same tree. The key traversal rules are: preorder: root -> left -> right inorder:...
leetcode tree binary-tree dfs recursion hash-map May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 21: Merge Two Sorted Lists

Problem Restatement We are given the heads of two sorted linked lists: list1 list2 Both lists are sorted in non-decreasing order. We need to merge them into one sorted linked list and return the head of the merged list. The merged list should be made by splicing together the nodes of the original two lists. The constraints say the total number of nodes across both lists is in the range...
leetcode linked-list recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 104: Maximum Depth of Binary Tree

Problem Restatement We are given the root of a binary tree. We need to return its maximum depth. The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node. The official statement uses this same definition. For this tree: 3 / \ 9 20 / \ 15 7 The longest root-to-leaf path is: 3 -> 20 -> 15 or:...
leetcode tree binary-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 04xx ›

LeetCode 404: Sum of Left Leaves

Problem Restatement We are given the root of a binary tree. A leaf node is a node with no children: node.left is None and node.right is None A left leaf is a leaf node that is also the left child of its parent. We must return the sum of all left leaves in the tree. Input and Output Item Meaning Input The root of a binary tree Output The sum...
leetcode tree dfs binary-tree recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 156: Binary Tree Upside Down

Problem Restatement We are given the root of a binary tree. We need to flip the tree upside down and return the new root. The transformation follows these rules: The original left child becomes the new root of that local subtree. The original root becomes the new right child. The original right child becomes the new left child. The operation is done level by level. The input has an important...
leetcode binary-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 04xx ›

LeetCode 430: Flatten a Multilevel Doubly Linked List

Problem Restatement We are given the head of a multilevel doubly linked list. Each node has four fields: Field Meaning val Node value prev Previous node on the same level next Next node on the same level child Head of another doubly linked list The child list can also contain nodes with their own child lists. We need to flatten everything into one single-level doubly linked list. When a node...
leetcode linked-list doubly-linked-list dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 129: Sum Root to Leaf Numbers

Problem Restatement We are given the root of a binary tree. Each node contains a digit from 0 to 9 . Every root-to-leaf path represents one number. For example, the path 1 -> 2 -> 3 represents the number 123 . We need to return the sum of all numbers formed by all root-to-leaf paths. A leaf is a node with no children. The answer is guaranteed to fit in...
leetcode Medium tree dfs binary-tree recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 04xx ›

LeetCode 428: Serialize and Deserialize N-ary Tree

Problem Restatement We are given an N-ary tree. An N-ary tree is a rooted tree where each node can have zero or more children. We need to design two methods: Method Meaning serialize(root) Convert the tree into a string deserialize(data) Convert the string back into the original tree There is no required serialization format. We can choose any format as long as it can rebuild the same tree structure. The...
leetcode tree n-ary-tree dfs serialization recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 04xx ›

LeetCode 427: Construct Quad Tree

Problem Restatement We are given an n x n grid containing only 0 and 1 . We need to build a quad tree that represents this grid. A quad tree is a tree where each internal node has exactly four children: Child Region topLeft upper-left quadrant topRight upper-right quadrant bottomLeft lower-left quadrant bottomRight lower-right quadrant Each node has two main fields: Field Meaning val True for 1 , False for...
leetcode matrix tree quad-tree divide-and-conquer recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 03xx ›

LeetCode 326: Power of Three

Problem Restatement We are given an integer n . Return true if n is a power of three. Otherwise, return false . A number is a power of three when it can be written as: n = 3^x where x is an integer. Examples: 27 = 3^3 9 = 3^2 3 = 3^1 1 = 3^0 So 27 , 9 , 3 , and 1 are powers of three. Numbers...
leetcode math recursion number-theory May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 02xx ›

LeetCode 226: Invert Binary Tree

Problem Restatement We are given the root of a binary tree. We need to invert the tree and return its root. Inverting means every node swaps its left child and right child. For example, LeetCode gives this input and output: root = [4,2,7,1,3,6,9] becomes [4,7,2,9,6,3,1] . The constraints say the tree has between 0 and 100 nodes, and each node value is between -100 and 100 . Input and Output...
leetcode binary-tree dfs recursion May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 77: Combinations

Problem Restatement We are given two integers: n: int k: int We need to return all possible combinations of k numbers chosen from the range: 1, 2, 3, ..., n The order of combinations in the answer does not matter. Inside one combination, order also does not define a new result. For example, [1, 2] and [2, 1] are the same combination. The official constraints are 1 <= n <=...
leetcode backtracking recursion combinations May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 00xx ›

LeetCode 10: Regular Expression Matching

Problem Restatement We are given two strings: s p s is the input string. p is the pattern. The pattern supports two special characters: Pattern symbol Meaning . Matches any single character * Matches zero or more of the preceding element The match must cover the entire input string, not only part of it. This is the key rule in the problem statement. For example: s = "aa" p =...
leetcode string dynamic-programming recursion memoization May 10, 2026
Practice › LeetCode › LeetCode (archived) › LeetCode 01xx ›

LeetCode 101: Symmetric Tree

Problem Restatement We are given the root of a binary tree. We need to check whether the tree is symmetric around its center. In other words, the left subtree must be a mirror image of the right subtree. The official problem asks whether the binary tree is a mirror of itself. A tree like this is symmetric: 1 / \ 2 2 / \ / \ 3 4 4 3...
leetcode tree binary-tree dfs recursion May 10, 2026
Programming › Algorithm Cookbook › Chapter 1. Foundations ›

1.5 Recursion Invariants

Recursive algorithms replace loop structure with self-reference. Instead of tracking progress through iteration, you track progress through problem size. A recursion invariant describes what each call is responsible for computing and how that responsibility relates to smaller subproblems. The core idea is simple: every recursive call must solve a strictly smaller instance of the same problem, and the combination of those solutions must produce a correct result for the original...
algorithms computer-science complexity foundations recursion May 3, 2026
Maths › 00. General Mathematics ›

07.3 Induction and Recursion

7.3 Induction and Recursion Induction is the standard proof technique for objects built in stages. Recursion is the matching construction technique. Together they describe how to define, compute, and prove statements about natural numbers, lists, trees, syntax, algorithms, and other generated structures. The simplest form is mathematical induction on natural numbers. To prove a statement $P(n)$ for every natural number $n$, prove two things. First, prove the base case: $$...
mathematics proof induction recursion May 2, 2026
Maths › 00. General Mathematics ›

06.5 Recursion and Induction

6.5 Recursion and Induction Recursion and induction are paired patterns. Recursion defines objects step by step. Induction proves statements about objects built step by step. The natural numbers give the basic model. Start with $0$. Then repeatedly apply the successor operation: $$ 0,\quad 1,\quad 2,\quad 3,\quad \dots $$ Each number is either the starting value or obtained from an earlier number. This recursive construction supports the principle of induction. To...
mathematics patterns recursion induction structure May 2, 2026
Wiki › Algorithms › 01. Searching and Sorting › 1. Linear and Sequential Search ›

Recursive Linear Search

Recursive Linear Search Recursive linear search expresses the same logic as iterative linear search using recursion. At each step, the problem reduces to searching a smaller suffix of the array. This form is mainly useful for reasoning, proofs, or when working in a recursive framework. In practice, iteration is usually preferred due to lower overhead. Problem Given a sequence $A$ of length $n$ and a value $x$, find an index...
algorithms searching recursion
Wiki › Algorithms › 01. Searching and Sorting › 2. Binary Search and Ordered Search ›

Recursive Binary Search

Recursive Binary Search Recursive binary search expresses the same divide and conquer strategy as binary search, but uses function calls instead of a loop. Each call reduces the search interval by half. This form is closer to the mathematical definition of the algorithm, though it introduces call stack overhead. Problem Given a sorted array $A$ of length $n$ and a value $x$, find an index $i$ such that $$ A[i]...
algorithms searching binary-search recursion