Examples

Example 1:

Input: n = 39
Output: 3

39 = 100111₂
  39 + 1 = 40 (101000₂)     op 1: +2⁰
  40 - 8 = 32 (100000₂)     op 2: -2³
  32 - 32 = 0               op 3: -2⁵

Example 2:

Input: n = 54
Output: 3

54 = 110110₂
  54 + 2 = 56 (111000₂)     op 1: +2¹
  56 + 8 = 64 (1000000₂)    op 2: +2³
  64 - 64 = 0               op 3: -2⁶

Constraints

• 1 <= n <= 10^5

Thinking Process

Binary Perspective

Every number is already a sum of powers of 2 (its binary representation). Each 1 bit could be removed by subtracting that power – that’s the naive approach, costing popcount(n) operations.

But we can do better by adding a power of 2 to create carries that collapse consecutive 1s.

When to Add vs Subtract

n = 7 = 111₂

Naive (subtract each bit): 4 + 2 + 1 → 3 ops
Smart: 7 + 1 = 8 (1000₂), then 8 - 8 = 0 → 2 ops

Adding 1 to a block of consecutive 1s collapses them all into a single 1 at a higher position.

The Greedy Rule

Scan from LSB to MSB:

• Bit is 0 – shift right, nothing to do
• Bit is 1:
  • If the next bit is also 1 (i.e., n & 3 == 3) – add 1 (carry forward to collapse the block)
  • Otherwise (isolated 1) – subtract 1 (cheaper to just remove it)

Each add/subtract counts as one operation. Shifting doesn’t count (we’re just moving to the next bit position).

Solution 1: Greedy Bit Manipulation – $O(\log n)$ time, $O(1)$ space

class Solution {
    public int minOperations(int n) {
        int ops = 0;
        while (n > 0) {
            if ((n 1) == 0) {
                n >>= 1;
            } else if (n == 1) {
                return ops + 1;
            } else if ((n 3) == 3) {
                n += 1;
                ops++;
            } else {
                n -= 1;
                ops++;
            }
        }
        return ops;
    }
}

Walk-through: n = 23 (10111₂)

Step   n (binary)   Action     ops
─────  ───────────  ─────────  ───
  1    10111        n&3=11 → +1   1
  2    11000        shift >>
  3    1100         shift >>
  4    110          shift >>
  5    11           n&3=11 → +1   2
  6    100          shift >>
  7    10           shift >>
  8    1            n==1 → +1     3

Result: 3 operations (not 6 – the earlier walkthrough in the problem had a bug; let’s verify: 23 + 1 = 24 = 11000₂, then 24 + 8 = 32 = 100000₂, then 32 - 32 = 0. That’s 3 ops.)

Walk-through: n = 7 (111₂)

Step   n (binary)   Action     ops
─────  ───────────  ─────────  ───
  1    111          n&3=11 → +1   1
  2    1000         shift >>
  3    100          shift >>
  4    10           shift >>
  5    1            n==1 → +1     2

Result: 2 operations (7 + 1 = 8, 8 - 8 = 0)

Solution 2: BFS – $O(n \log n)$ time, $O(n)$ space

BFS explores all reachable states layer by layer, guaranteeing the shortest path. From any value, try adding or subtracting every power of 2.

// import java.util.*;
class Solution {
    public int minOperations(int n) {
        if (n == 0) return 0;

        HashSet<Integer> visited = new HashSet<Integer>();
        Queue<Integer> q = new LinkedList<>();
        q.push(n);
        visited.add(n);
        int ops = 0;

        while (!q.length == 0) {
            int size = q.size();
            ops++;
            for (int i = 0; i < size; ++i) {
                int cur = q.getFirst();
                q.pop();

                for (int p = 1; p <= 1 << 17; p <<= 1) {
                    for (int next : {cur + p, cur - p}) {
                        if (next == 0) return ops;
                        if (next > 0 && next < (1 << 18) && !visited.count(next)) {
                            visited.add(next);
                            q.push(next);
                        }
                    }
                }
            }
        }
        return -1;
    }
}

Why the Bound 1 << 18?

Since n <= 10^5 < 2^17, adding a power of 2 can at most double the value. We cap the search space at 2^18 to prevent exploring irrelevant large numbers. In practice BFS terminates very quickly since the greedy answer is at most $O(\log n)$ operations.

Comparison

BFS is useful as a verification tool: run it on small inputs to confirm the greedy produces optimal results. In interviews, mentioning BFS as a brute-force baseline before presenting the greedy shows strong problem-solving structure.

Why the Greedy is Optimal

Consider a block of $k$ consecutive 1s:

For $k \ge 3$, adding is strictly better. For $k = 2$ (like 11₂ = 3), both cost 2 operations:

• Add: $3 + 1 = 4$, $4 - 4 = 0$ (2 ops)
• Subtract: $3 - 1 = 2$, $2 - 2 = 0$ (2 ops)

The greedy chooses to add for k >= 2, which is safe since it never costs more.

Common Mistakes

• Treating n = 1 separately: After all shifts, n == 1 is the base case (isolated single bit). Forgetting this causes infinite loops.
• Using n & 1 == 1 instead of n & 3 == 3: The decision depends on whether the next bit is also set, not just the current bit
• Counting shifts as operations: Shifting is just moving to the next bit position, not an actual add/subtract operation
• BFS without bounds: Without capping the search space, BFS explodes in memory

Key Takeaways

• Think in binary when the problem involves powers of 2
• Consecutive 1s can be collapsed by adding 1 – this is the core greedy insight
• Check n & 3 == 3 (two lowest bits both set) to decide add vs subtract
• BFS gives a provably optimal baseline; greedy gives $O(\log n)$ performance
• The pattern “add to create carry, then subtract” appears in many bit manipulation problems

Related Problems

• 397. Integer Replacement – similar greedy on even/odd with bit analysis
• 191. Number of 1 Bits – popcount baseline
• 1342. Number of Steps to Reduce a Number to Zero – simpler version with only divide/subtract
• 260. Single Number III – bit manipulation with XOR

Template Reference

• Math & Bit Manipulation

Examples

Example 1:

Input: s = "aabb"
Output: 11

Good subsequences:
  k=1: "a","a","b","b","ab","ab","ab","ab" → 8
  k=2: "aa","bb","aabb" → 3
  Total = 11

Example 2:

Input: s = "leet"
Output: 7

freq: l=1, e=2, t=1
  k=1: "l","e","e","t","le","lt","et","le","lt","et" ...
  (counted via formula below)

Constraints

• 1 <= s.length <= 10^4
• s consists of lowercase English letters only

Thinking Process

Why Brute Force Fails

Enumerating all $2^n - 1$ non-empty subsequences and checking each one is exponential. We need a combinatorial approach.

The Key Insight

Instead of generating subsequences, fix a target frequency k and count how many subsequences have every chosen character appearing exactly k times.

For a fixed k:

• For each character c with freq[c] >= k, we can either include it (choose exactly k of its freq[c] occurrences: $\binom{freq[c]}{k}$ ways) or exclude it entirely (1 way)
• Characters with freq[c] < k must be excluded

So the total for a given k:

The $-1$ removes the empty subsequence (where every character is excluded).

Final Answer

Efficient Combinations

We need $\binom{n}{k}$ for various $n, k$ up to $\max_freq$. Using a Pascal table would be $O(n^2)$ memory, which can blow up for large frequencies.

Instead, precompute factorials and use Fermat’s little theorem for modular inverse:

Solution 1: Per-Character Loop – $O(\text{maxFreq} \times 26)$ time

// import java.util.*;
class Solution {
    public static int MOD = 1e9 + 7;

    public long modPow(long a, long b) {
        long res = 1;
        while (b) {
            if (b 1) res = res a % MOD;
            a = a a % MOD;
            b >>= 1;
        }
        return res;
    }

    int countGoodSubsequences(String s) {
        HashMap<char, int> freq = new HashMap<char, int>();
        for (char c : s) freq.put(c, freq.getOrDefault(c, 0) + 1);

        int max_f = 0;
        for (auto& [c, f] : freq) max_f = Math.max(max_f, f);

        long[]fact(max_f + 1, 1), invfact(max_f + 1, 1);
        for (int i = 1; i <= max_f; i++) {
            fact.put(i, fact[i - 1] * i % MOD);
        }
        invfact.put(max_f, modPow(fact[max_f], MOD - 2));
        for (int i = max_f - 1; i >= 0; i--) {
            invfact.put(i, invfact[i + 1] * (i + 1) % MOD);
        }

        var comb = [&](int n, int k) {
            return fact[n] % MOD invfact[k] % MOD invfact[n - k] % MOD;
        }
        long result = 0;
        for (int k = 1; k <= max_f; k++) {
            long ways = 1;
            for (auto& [c, f] : freq) {
                if (f >= k) {
                    ways = ways * (1 + comb(f, k)) % MOD;
                }
            }
            ways = (ways - 1 + MOD) % MOD;
            result = (result + ways) % MOD;
        }
        return result;
    }
}

Time: $O(\text{maxFreq} \times |\Sigma|)$ where $|\Sigma| \le 26$ Space: $O(\text{maxFreq})$ for factorial arrays

Solution 2: Frequency Grouping – $O(\text{maxFreq} \times d)$ time

When multiple characters share the same frequency, we can group them and use exponentiation instead of iterating each one individually.

// import java.util.*;
class Solution {
    public static int MOD = 1e9 + 7;

    public long modPow(long a, long b) {
        long res = 1;
        while (b) {
            if (b 1) res = res a % MOD;
            a = a a % MOD;
            b >>= 1;
        }
        return res;
    }

    int countGoodSubsequences(String s) {
        HashMap<char, int> freq = new HashMap<char, int>();
        for (char c : s) freq.put(c, freq.getOrDefault(c, 0) + 1);

        HashMap<Integer, Integer> freqCount = new HashMap<Integer, Integer>();
        for (auto& [c, f] : freq) freqCount.put(f, freqCount.getOrDefault(f, 0) + 1);

        int max_f = 0;
        for (auto& [f, cnt] : freqCount) max_f = Math.max(max_f, f);

        long[]fact(max_f + 1, 1), invfact(max_f + 1, 1);
        for (int i = 1; i <= max_f; i++) {
            fact.put(i, fact[i - 1] * i % MOD);
        }
        invfact.put(max_f, modPow(fact[max_f], MOD - 2));
        for (int i = max_f - 1; i >= 0; i--) {
            invfact.put(i, invfact[i + 1] * (i + 1) % MOD);
        }

        var comb = [&](int n, int k) {
            return fact[n] % MOD invfact[k] % MOD invfact[n - k] % MOD;
        }
        long result = 0;
        for (int k = 1; k <= max_f; k++) {
            long ways = 1;
            for (auto& [f, count] : freqCount) {
                if (f >= k) {
                    long val = (1 + comb(f, k)) % MOD;
                    ways = ways modPow(val, count) % MOD;
                }
            }
            ways = (ways - 1 + MOD) % MOD;
            result = (result + ways) % MOD;
        }
        return result;
    }
}

Time: $O(\text{maxFreq} \times d)$ where $d$ = number of distinct frequencies ($d \le 26$) Space: $O(\text{maxFreq})$

Why Group by Frequency?

If 10 characters all have frequency 5, Solution 1 multiplies (1 + C(5, k)) ten separate times. Solution 2 computes (1 + C(5, k))^10 in one modPow call. With at most 26 letters, $d \le 26$, so this doesn’t change asymptotic complexity but reduces constant factor work, especially when many characters share frequencies (e.g., "aabbccddee...").

Walk-through: s = "aabb"

freq: a=2, b=2
max_f = 2

k=1:
  char a: 1 + C(2,1) = 1 + 2 = 3
  char b: 1 + C(2,1) = 1 + 2 = 3
  ways = 3 × 3 - 1 = 8

k=2:
  char a: 1 + C(2,2) = 1 + 1 = 2
  char b: 1 + C(2,2) = 1 + 1 = 2
  ways = 2 × 2 - 1 = 3

result = 8 + 3 = 11  ✓

Why Not Pascal’s Triangle?

For inputs like "jjjjjj..." (single character, frequency $10^4$), a Pascal table would need $O(n^2)$ space – up to $10^8$ entries. The factorial + modular inverse approach uses only $O(n)$ space and computes each $\binom{n}{k}$ in $O(1)$.

Common Mistakes

• Forgetting the $-1$: The product includes the case where every character is excluded (empty subsequence), which must be subtracted
• Not clamping combinations: Only characters with freq[c] >= k contribute; others must be skipped (their factor is just 1)
• Using Pascal table for large $n$: Causes MLE; always use factorial arrays with Fermat inverse
• Missing modular arithmetic: Intermediate products can overflow without % MOD at each step

Key Takeaways

• “Fix a parameter and count” is a powerful combinatorial strategy – here we fix the target frequency k
• For each character, the choice is binary: include (choose $k$ copies) or exclude – giving a product formula
• Modular inverse via Fermat’s little theorem ($a^{-1} \equiv a^{p-2} \pmod{p}$) is essential for efficient $\binom{n}{k}$ under modulo
• Grouping by frequency is a clean optimization when characters share the same count

Related Problems

• 1569. Number of Ways to Reorder Array to Get Same BST – combinatorics with modular inverse
• 62. Unique Paths – basic combinatorics $\binom{m+n-2}{m-1}$
• 1512. Number of Good Pairs – frequency counting
• 940. Distinct Subsequences II – subsequence counting with DP

From each cell, you can move in four directions: up, down, left, or right. You may not move diagonally or outside the boundary.

Examples

Example 1:

Input:
  9  9  4
  6  6  8
  2  1  1

Output: 4

One longest path: 1 → 2 → 6 → 9

Example 2:

Input:
  3  4  5
  3  2  6
  2  2  1

Output: 4

One longest path: 3 → 4 → 5 → 6

Constraints

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 200
• 0 <= matrix[i][j] <= 2^31 - 1

Thinking Process

Why Brute Force Fails

Starting DFS from every cell without caching repeats enormous amounts of work. A cell deep in the matrix gets re-explored from every path that leads to it.

DFS + Memoization

Define dp[i][j] = length of the longest increasing path starting from (i, j).

From (i, j), try all 4 neighbors (nr, nc) where matrix[nr][nc] > matrix[i][j]:

dp[i][j] = 1 + max(dp[nr][nc]) for all valid strictly-greater neighbors

If no neighbor is strictly greater, dp[i][j] = 1.

Since values are strictly increasing, there are no cycles. Each cell is computed exactly once, then cached.

Alternative: Topological Sort (BFS)

Think of the grid as a DAG: draw an edge u → v whenever matrix[v] > matrix[u]. Then the longest increasing path = longest path in this DAG, which we can find via topological sort (Kahn’s algorithm):

1. Compute indegree of each cell (number of strictly-smaller neighbors)
2. Start BFS from all cells with indegree 0 (local minima)
3. Process layer by layer; each layer = one step in the path
4. Number of BFS layers = answer

Solution 1: DFS + Memoization – $O(mn)$ time, $O(mn)$ space

class Solution {
    public int longestIncreasingPath(int[][]& matrix) {
        if (matrix.length == 0) return 0;
        int rows = matrix.size();
        int cols = matrix[0].length;
        int[][] dp = new int[rows][cols];
        int result = 0;

        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                result = Math.max(result, dfs(matrix, dp, i, j));
            }
        }
        return result;
    }
    int dirs[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
    int dfs(int[][]& matrix, int[][]& dp, int r, int c) {
        if (dp[r][c] !) return dp[r][c];
        int rows = matrix.size();
        int cols = matrix[0].length;
        int maxLen = 1;

        for (auto d : dirs) {
            int nr = r + d[0];
            int nc = c + d[1];
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
                matrix[nr][nc] > matrix[r][c]) {
                maxLen = Math.max(maxLen, 1 + dfs(matrix, dp, nr, nc));
            }
        }
        dp[r][c] = maxLen;
        return maxLen;
    }
}

Why No Visited Array?

Unlike typical grid DFS, we don’t need a visited set. The strictly increasing constraint guarantees no cycles – you can never return to a cell you’ve already visited on the current path since its value would have to be both smaller and larger.

Why Memoization Works

Once dp[r][c] is computed, every future call that reaches (r, c) returns immediately. Each cell is fully explored exactly once, so total work across all DFS calls is $O(mn)$.

Solution 2: Topological Sort (BFS) – $O(mn)$ time, $O(mn)$ space

class Solution {
    public int longestIncreasingPath(int[][]& matrix) {
        if (matrix.length == 0) return 0;
        int rows = matrix.size();
        int cols = matrix[0].length;

        int[][] indegree = new int[rows][cols];
        int dirs[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}
        for (int r = 0; r < rows; ++r) {
            for (int c = 0; c < cols; ++c) {
                for (auto d : dirs) {
                    int nr = r + d[0];
                    int nc = c + d[1];
                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
                        matrix[nr][nc] < matrix[r][c]) {
                        indegree[r][c]++;
                    }
                }
            }
        }

        queue<int[]> q;
        for (int r = 0; r < rows; ++r) {
            for (int c = 0; c < cols; ++c) {
                if (indegree[r][c] == 0) {
                    q.push({r, c});
                }
            }
        }

        int pathLen = 0;
        while (!q.length == 0) {
            int size = q.size();
            pathLen++;
            for (int i = 0; i < size; ++i) {
                auto [r, c] = q.getFirst();
                q.pop();
                for (auto d : dirs) {
                    int nr = r + d[0];
                    int nc = c + d[1];
                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
                        matrix[nr][nc] > matrix[r][c]) {
                        if (--indegree[nr][nc] == 0) {
                            q.push({nr, nc});
                        }
                    }
                }
            }
        }
        return pathLen;
    }
}

Walk-through

Matrix:
  9  9  4
  6  6  8
  2  1  1

Indegree (# of strictly smaller neighbors):
  2  2  1
  1  1  2
  0  0  0

Layer 0 (indegree=0): (2,0)=2, (2,1)=1, (2,2)=1   pathLen=1
  Process: decrement neighbors' indegrees

Layer 1: (1,0)=6, (1,1)=6, (0,2)=4                  pathLen=2

Layer 2: (0,0)=9, (0,1)=9, (1,2)=8                  pathLen=3

Layer 3: (nothing new? let's trace...)
  Actually: after layer 1, (1,2)=8 gets indegree 0
  After layer 2, nothing remains

pathLen = 4  ✓

Comparison

Common Mistakes

• Forgetting the strictly-greater check: Using >= instead of > creates cycles and infinite recursion
• Using a visited array: Unnecessary here and would actually prevent correct memoization (a cell should be reachable from multiple starting points)
• Returning 0 for base case: A single cell is a path of length 1, not 0

Key Takeaways

• DFS + memoization on grid is a core pattern: define dp[i][j] as the answer starting from (i, j), recurse on valid neighbors, cache results
• Strictly increasing guarantees a DAG – no cycles means memoization is safe and topological sort applies
• The BFS approach reveals the problem’s structure: it’s just longest path in a DAG disguised as a grid problem
• Both solutions are $O(mn)$ – choose based on whether you prefer recursive or iterative style

Related Problems

• 200. Number of Islands – grid DFS without memoization
• 417. Pacific Atlantic Water Flow – grid DFS with multi-source
• 1091. Shortest Path in Binary Matrix – grid BFS
• 221. Maximal Square – grid DP with neighbor transitions
• 207. Course Schedule – topological sort on explicit DAG

Template Reference

• DFS
• Dynamic Programming

Examples

Example 1:

Input:
  1 0 1 0 0
  1 0 1 1 1
  1 1 1 1 1
  1 0 0 1 0

Output: 4   (a 2x2 square)

Example 2:

Input:
  0 1
  1 0

Output: 1   (a 1x1 square)

Example 3:

Input:
  0

Output: 0

Constraints

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 300
• matrix[i][j] is '0' or '1'

Thinking Process

The DP Definition

Define dp[i][j] = side length of the largest square whose bottom-right corner is at (i, j).

The Transition

A square at (i, j) can only be as large as the smallest of its three neighbors plus one:

dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])

Why? A square of side k at (i, j) requires:

• A square of side k-1 ending at (i-1, j) (top)
• A square of side k-1 ending at (i, j-1) (left)
• A square of side k-1 ending at (i-1, j-1) (diagonal)

If any of these is smaller, it becomes the bottleneck.

  ┌──────────┐
  │ diag  top│
  │ left  cur│
  └──────────┘

dp[i-1][j-1]  dp[i-1][j]
dp[i][j-1]    dp[i][j] = 1 + min(top, left, diag)

Complete Walk-through

Matrix:                    DP table:
1 0 1 0 0                 1 0 1 0 0
1 0 1 1 1                 1 0 1 1 1
1 1 1 1 1                 1 1 1 2 2
1 0 0 1 0                 1 0 0 1 0

Key cells:

• dp[2][3]: min(top=1, left=1, diag=1) + 1 = 2 – a 2x2 square forms
• dp[2][4]: min(top=1, left=2, diag=1) + 1 = 2 – another 2x2 square
• dp[3][3]: min(top=2, left=0, diag=1) + 1 = 1 – left is 0, so only 1x1

Max value = 2, so answer = $2^2 = 4$.

Solution 1: 2D DP – $O(mn)$ time, $O(mn)$ space

class Solution {
    public int maximalSquare(char[][]& matrix) {
        if (matrix.length == 0) return 0;
        int rows = matrix.size();
        int cols = matrix[0].length;

        int[][] dp = new int[rows][cols];
        int maxSide = 0;

        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1;
                    } else {
                        dp[i][j] = 1 + Math.min({
                            dp[i - 1][j],
                            dp[i][j - 1],
                            dp[i - 1][j - 1]
                        });
                    }
                    maxSide = Math.max(maxSide, dp[i][j]);
                }
            }
        }
        return maxSide maxSide;
    }
}

The first row and first column are base cases: if matrix[i][j] == '1', then dp[i][j] = 1 (a 1x1 square at most).

Solution 2: Space-Optimized 1D DP – $O(mn)$ time, $O(n)$ space

Since each row only depends on the current and previous row, we can use a single 1D array.

class Solution {
    public int maximalSquare(char[][]& matrix) {
        if (matrix.length == 0) return 0;
        int rows = matrix.size();
        int cols = matrix[0].length;

        int[] dp = new int[cols];
        int maxSide = 0;
        int prev = 0;

        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                int temp = dp[j];
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) {
                        dp[j] = 1;
                    } else {
                        dp[j] = 1 + Math.min({dp[j], dp[j - 1], prev});
                    }
                    maxSide = Math.max(maxSide, dp[j]);
                } else {
                    dp[j] = 0;
                }
                prev = temp;
            }
        }
        return maxSide maxSide;
    }
}

Variable Mapping

The trick is saving dp[j] into prev before overwriting it, so the diagonal value from the previous row isn’t lost.

Why min of Three Neighbors?

Consider why we can’t just check one or two neighbors:

Case: top=3, left=3, diag=1

    . . . .
    . 1 1 .
    . 1 1 .      ← diag is the bottleneck
    . . 1 ?

Even though top and left support a 3x3,
the diagonal gap limits us to a 2x2.

All three must agree for a larger square to exist. The minimum captures the tightest constraint.

Common Mistakes

• Returning maxSide instead of maxSide * maxSide: The problem asks for area, not side length
• Treating matrix[i][j] as int: The matrix contains char values ('0'/'1'), not integers
• Forgetting to reset dp[j] = 0 in 1D version: When matrix[i][j] == '0', the cell must be explicitly zeroed

Key Takeaways

• Classic 2D DP pattern: define state at each cell, derive from neighbors
• The min of three neighbors is the core insight – a square is only as large as its weakest constraint
• Space optimization from 2D to 1D is a standard technique: save the diagonal before overwriting
• Answer is $\text{maxSide}^2$ (area, not side length)

Related Problems

• 85. Maximal Rectangle – harder generalization using histogram approach
• 1277. Count Square Submatrices with All Ones – same DP, sum all dp[i][j] values
• 62. Unique Paths – similar 2D DP grid pattern
• 64. Minimum Path Sum – 2D DP with neighbor transitions

Template Reference

• Dynamic Programming

The h-index is defined as: the maximum value of h such that the researcher has published at least h papers that have each been cited at least h times.

Examples

Example 1:

Input: citations = [3, 0, 6, 1, 5]
Output: 3

Sort descending: [6, 5, 3, 1, 0]

  i (papers seen)   citations[i]   >= i+1 ?
  1                 6              >= 1  YES
  2                 5              >= 2  YES
  3                 3              >= 3  YES
  4                 1              >= 4  NO   ← stop

Answer = 3 (3 papers with >= 3 citations each)

Example 2:

Input: citations = [1, 3, 1]
Output: 1

Constraints

• n == citations.length
• 1 <= n <= 5000
• 0 <= citations[i] <= 1000

Thinking Process

What Are We Really Looking For?

This is not about total citations. It’s about finding a balance point: the largest h where at least h papers have >= h citations.

Why Sorting Works

After sorting in descending order:

• Position i+1 = number of papers we’ve seen so far
• Value citations[i] = the citation count of the current paper

At each position, we’re asking: “Does this paper have enough citations to support the current count of papers?”

The moment citations[i] < i + 1, the balance breaks and we’ve found our answer.

Sorted: [6, 5, 3, 1, 0]

Index 0: 6 >= 1  →  at least 1 paper with >= 1 citations  ✓
Index 1: 5 >= 2  →  at least 2 papers with >= 2 citations ✓
Index 2: 3 >= 3  →  at least 3 papers with >= 3 citations ✓
Index 3: 1 >= 4  →  at least 4 papers with >= 4 citations ✗  ← STOP

h = 3

Can We Do Better Than $O(n \log n)$?

Yes – since h can be at most n, we can use counting sort to get $O(n)$.

Solution 1: Sort Descending – $O(n \log n)$ time, $O(1)$ space

class Solution {
    public int hIndex(int[] citations) {
        sort(citations /* elements of citations */, greater<int>());
        for (int i = 0; i < citations.size(); ++i) {
            if (citations[i] < i + 1) return i;
        }
        return citations.size();
    }
}

If every paper has enough citations, the loop finishes without returning, and h = n.

Solution 2: Counting Sort – $O(n)$ time, $O(n)$ space

class Solution {
    public int hIndex(int[] citations) {
        int n = citations.size();
        int[] count = new int[n + 1];

        for (int c : citations) {
            count[Math.min(c, n)]++;
        }

        int total = 0;
        for (int h = n; h >= 0; --h) {
            total += count[h];
            if (total >= h) return h;
        }
        return 0;
    }
}

How It Works

1. Build a frequency array count[i] = number of papers with exactly i citations. Papers with >= n citations are bucketed into count[n] since h can never exceed n.

2. Scan from h = n down to 0, accumulating the total number of papers with >= h citations. The first h where total >= h is the answer.

citations = [3, 0, 6, 1, 5],  n = 5

count:  index  0  1  2  3  4  5
        value  1  1  0  1  0  2   (6 and 5 both go into bucket 5)

Scan from h=5:  total=2, 2 >= 5?  no
      h=4:  total=2, 2 >= 4?  no
      h=3:  total=3, 3 >= 3?  YES → return 3

Comparison

Common Mistakes

• Confusing h-index with max citations: h is bounded by the number of papers, not the citation values
• Off-by-one in sorting approach: Position i means i + 1 papers (0-indexed), so the check is citations[i] < i + 1
• Forgetting the min(c, n) clamp in counting sort: Any citation count >= n is equivalent since h <= n

Key Takeaways

• The h-index is a balance point between quantity (number of papers) and quality (citation count)
• Sort descending and scan gives the most intuitive solution
• Counting sort exploits the fact that h <= n to achieve linear time
• This pattern of “find the largest k satisfying a threshold” appears in many problems

Related Problems

• 275. H-Index II – sorted input, use binary search for $O(\log n)$
• 287. Find the Duplicate Number – counting / pigeonhole
• 169. Majority Element – finding a threshold in an array

Examples

Example 1:

Input: head = [1,2,3,4,5], left = 2, right = 4
Output: [1,4,3,2,5]

1 → [2 → 3 → 4] → 5
      ↓ reverse ↓
1 → [4 → 3 → 2] → 5

Example 2:

Input: head = [5], left = 1, right = 1
Output: [5]

Constraints

• 1 <= n <= 500 (number of nodes)
• -500 <= Node.val <= 500
• 1 <= left <= right <= n

Thinking Process

Break It Into 3 Parts

1. Traverse to the node before left – call it prev
2. Reverse the sublist [left .. right]
3. Reconnect: prev → new head of reversed sublist, tail of reversed sublist → node after right

The Head Insertion Trick

Instead of doing a standard three-pointer reversal and then reconnecting, we can use head insertion: repeatedly pull the node after curr to the front of the sublist. This avoids re-traversing and naturally keeps all connections intact.

Initial:  prev → [a → b → c → d] → next
                  ↑             ↑
                left          right

Step 1: move b before a
          prev → [b → a → c → d] → next

Step 2: move c before b
          prev → [c → b → a → d] → next

Step 3: move d before c
          prev → [d → c → b → a] → next

Each step does 3 pointer swaps and the sublist grows by one node at the front.

Edge Cases

Solution 1: Head Insertion – $O(n)$ time, $O(1)$ space

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (!head || left == right) return head;

        ListNode dummy(0);
        dummy.next = head;
        ListNode prev = &dummy;

        for (int i = 1; i < left; ++i) {
            prev = prev.next;
        }

        ListNode curr = prev.next;
        for (int i = 0; i < right - left; ++i) {
            ListNode tmp = curr.next;
            curr.next = tmp.next;
            tmp.next = prev.next;
            prev.next = tmp;
        }

        return dummy.next;
    }
}

How the Inner Loop Works

Each iteration moves curr->next to the front of the sublist:

Before iteration:   prev → [... → curr → tmp → rest]
After iteration:    prev → [tmp → ... → curr → rest]

• curr->next = tmp->next – detach tmp from its position
• tmp->next = prev->next – point tmp to the current front of the sublist
• prev->next = tmp – make tmp the new front

Note that curr never moves – it starts as the first node of the sublist and ends as the last.

Solution 2: Classic Reversal – $O(n)$ time, $O(1)$ space

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (!head || left == right) return head;

        ListNode cur = head;
        ListNode pre = null;
        while (left > 1) {
            pre = cur;
            cur = cur.next;
            left--;
            right--;
        }

        ListNode con = pre;
        ListNode tail = cur;
        ListNode third = null;
        while (right > 0) {
            third = cur.next;
            cur.next = pre;
            pre = cur;
            cur = third;
            right--;
        }

        if (con != null) {
            con.next = pre;
        } else {
            head = pre;
        }
        tail.next = cur;

        return head;
    }
}

Walk-through

head = [1, 2, 3, 4, 5], left = 2, right = 4

Phase 1: Advance to position left
  pre = node(1), cur = node(2)   [left=1, right=3 after decrement]

Phase 2: Reverse right nodes starting from cur
  con = node(1)   (node before sublist)
  tail = node(2)  (will become tail of reversed sublist)

  Iteration 1: reverse 2→3  →  2←3   cur=node(3), pre=node(2)... wait
  Actually: 2→1 (wrong link, but ok), pre=2, cur=3, right=2
  Iteration 2: 3→2, pre=3, cur=4, right=1
  Iteration 3: 4→3, pre=4, cur=5, right=0

Phase 3: Reconnect
  con.next = pre  →  node(1).next = node(4)
  tail.next = cur →  node(2).next = node(5)

Result: 1 → 4 → 3 → 2 → 5  ✓

Comparison

Common Mistakes

• Off-by-one on prev: Walking left steps from dummy lands on node left, but we need node left - 1. Walk left - 1 steps instead.
• Moving curr in head insertion: curr should stay fixed – it’s always the tail of the growing reversed sublist. Only tmp moves.
• Forgetting left == 1: Without a dummy, the head of the list changes. Either use a dummy or handle this case explicitly.

Key Takeaways

• Head insertion is the cleanest pattern for partial reversal – no separate reconnection step needed
• A dummy node eliminates the left == 1 edge case entirely
• Both approaches are $O(n)$ time and $O(1)$ space – the choice is about clarity, not performance

Related Problems

• 206. Reverse Linked List – full list reversal
• 25. Reverse Nodes in k-Group – reverse segments of size k
• 24. Swap Nodes in Pairs – special case of k=2 reversal
• 1669. Merge In Between Linked Lists – similar pointer surgery on a sublist range

Template Reference

• Linked List

Examples

Example 1:

Input: list1 = [10,1,13,6,9,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
Output: [10,1,13,1000000,1000001,1000002,5]

list1:  10 → 1 → 13 → [6 → 9] → 5
                        ↑ remove ↑
list2:  1000000 → 1000001 → 1000002

Result: 10 → 1 → 13 → 1000000 → 1000001 → 1000002 → 5

Example 2:

Input: list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]
Output: [0,1,1000000,1000001,1000002,1000003,1000004,6]

Constraints

• 3 <= list1.length <= 10^4
• 1 <= a <= b < list1.length - 1
• 1 <= list2.length <= 10^4

The constraints guarantee a >= 1 and b < n - 1, so there is always at least one node before a and one node after b.

Thinking Process

What Do We Need?

We’re splicing list2 into list1 by removing positions a..b. That means three pointer rewirings:

prevA → list2_head → ... → list2_tail → afterB

We need:

1. prevA – the node at index a - 1 (just before the removed segment)
2. afterB – the node at index b + 1 (just after the removed segment)
3. tail2 – the last node of list2

Why No Dummy Node Needed?

Since a >= 1, the head of list1 is never removed, so we don’t need a dummy node to protect the head.

Walk-through

list1: 10 → 1 → 13 → 6 → 9 → 5     a=3, b=4
index:  0   1    2   3   4   5

Step 1: Walk to index a-1 = 2
  prevA = node(13)

Step 2: From prevA, walk (b - a + 1) more steps to reach node at index b
  then afterB = that node's next
  afterB = node(5)

Step 3: Find tail of list2
  list2: 1000000 → 1000001 → 1000002
  tail2 = node(1000002)

Step 4: Rewire
  prevA.next = list2         →  13 → 1000000
  tail2.next = afterB        →  1000002 → 5

Result: 10 → 1 → 13 → 1000000 → 1000001 → 1000002 → 5  ✓

Solution: Pointer Manipulation – $O(n + m)$ time, $O(1)$ space

class Solution {
    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
        ListNode dummy(0);
        dummy.next = list1;

        ListNode prevA = &dummy;
        for (int i = 0; i < a; ++i) {
            prevA = prevA.next;
        }

        ListNode afterB = prevA;
        for (int i = 0; i <= b - a; ++i) {
            afterB = afterB.next;
        }
        afterB = afterB.next;

        prevA.next = list2;

        ListNode tail = list2;
        while (tail.next) {
            tail = tail.next;
        }
        tail.next = afterB;

        return dummy.next;
    }
}

Time: $O(n + m)$ – traverse list1 up to index b, then traverse all of list2 Space: $O(1)$ – only pointer variables

Key Details

Without Dummy (Slightly Simpler)

Since the constraints guarantee a >= 1, we can skip the dummy:

class Solution {
    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
        ListNode prevA = list1;
        for (int i = 0; i < a - 1; ++i) {
            prevA = prevA.next;
        }

        ListNode afterB = prevA;
        for (int i = 0; i <= b - a + 1; ++i) {
            afterB = afterB.next;
        }

        prevA.next = list2;

        ListNode tail = list2;
        while (tail.next) {
            tail = tail.next;
        }
        tail.next = afterB;

        return list1;
    }
}

Common Mistakes

• Off-by-one on prevA: Walking a steps from head lands on index a, but we need index a - 1. Use a dummy or walk a - 1 steps.
• Off-by-one on afterB: Forgetting the final .next after reaching the node at index b.
• Forgetting to find tail2: The connection list2_tail → afterB is easy to miss if you only set prevA → list2.

Key Takeaways

• “Splice list into list” = find the boundary pointers (prevA, afterB) + find the tail of the inserted list + three pointer rewirings
• When the head can never be removed, a dummy node is optional but can simplify uniform traversal
• Constraints like a >= 1 and b < n - 1 eliminate edge cases – always read them carefully

Related Problems

• 206. Reverse Linked List – basic pointer manipulation
• 25. Reverse Nodes in k-Group – segment-based list surgery
• 86. Partition List – pointer rewiring with dummy nodes
• 143. Reorder List – find middle, reverse, merge

Template Reference

• Linked List

Examples

Example 1:

Input: events = [[1,2],[2,3],[3,4]]
Output: 3
Explanation: Attend all three:
  Day 1 → event [1,2]
  Day 2 → event [2,3]
  Day 3 → event [3,4]

Example 2:

Input: events = [[1,2],[2,3],[3,4],[1,2]]
Output: 4
Explanation:
  Day 1 → event [1,2] (first)
  Day 2 → event [1,2] (second)
  Day 2 → can't, already used. Day 3 → event [2,3]
  Day 4 → event [3,4]

Constraints

• 1 <= events.length <= 10^5
• events[i].length == 2
• 1 <= startDay <= endDay <= 10^5

Thinking Process

Key Observations

1. Each event is flexible – you don’t have to attend on the start day; any day in [start, end] works
2. Greedy insight: on any given day, attend the event that expires soonest (smallest end day). Delaying it risks losing it forever, while events with later deadlines are safer to postpone
3. Efficient simulation: move day by day, maintain available events in a min-heap, pick the one expiring soonest

Algorithm

1. Sort events by start day
2. Use a min-heap of end days (earliest deadline on top)
3. Iterate by day:
   • Add all newly available events (start day ≤ current day)
   • Remove expired events from the heap (end day < current day)
   • Attend the event with the smallest end day (pop from heap)
   • Advance to the next day

Walk-through

events (sorted): [[1,2], [1,2], [2,3], [3,4]]

Day 1: add [1,2],[1,2] → heap={2,2}
        attend end=2 → heap={2}, rtn=1

Day 2: add [2,3] → heap={2,3}
        attend end=2 → heap={3}, rtn=2

Day 3: add [3,4] → heap={3,4}
        attend end=3 → heap={4}, rtn=3

Day 4: attend end=4 → heap={}, rtn=4

Answer: 4 ✓

Why Skip to the Next Event’s Start?

If the heap is empty and there are more events, we jump day forward to events[i][0] instead of incrementing one by one. This avoids iterating through idle days and keeps the algorithm efficient.

Solution: Sort + Greedy Min-Heap – $O(n \log n)$

// import java.util.Arrays;
// import java.util.Collections;
class Solution {
    public int maxEvents(int[][]& events) {
        Arrays.sort(events);
        priority_queue<int, int[], greater<int>> pq;
        int n = events.size();
        int i = 0, day = 0, rtn = 0;

        while (i < n || !pq.length == 0) {
            if (pq.length == 0) day = events[i][0];
            while (i < n && events[i][0] <= day) {
                pq.push(events[i][1]);
                i++;
            }
            while (!pq.length == 0 && pq.top() < day) pq.pop();
            if (!pq.length == 0) {
                pq.pop();
                rtn++;
                day++;
            }
        }
        return rtn;
    }
}

Time: $O(n \log n)$ – sorting + each event enters/leaves the heap once Space: $O(n)$ – heap

Key Details

Why min-heap of end days (not start days)? We want to prioritize the event that expires soonest. Start days don’t matter once an event is available – only the deadline matters for the greedy choice.

Why pq.top() < day (not <=)? An event with end == day is still valid today. We only discard events whose end day is strictly before the current day.

Why the if (pq.empty()) day = events[i][0] jump? Without this, we’d increment day through potentially thousands of idle days. Jumping to the next event’s start keeps the outer loop proportional to $O(n)$ iterations.

Common Mistakes

• Sorting by end day instead of start day (need start day ordering to add events as days progress)
• Not removing expired events before picking (could “attend” an already-expired event)
• Incrementing day one by one even when the heap is empty (TLE on large gaps)

Key Takeaways

• “Maximize events attended with earliest-deadline-first” = sort by start + min-heap of end days
• This is a variant of the Earliest Deadline First (EDF) scheduling strategy
• The pattern of “add available → remove expired → pick best” is common in event scheduling problems

Related Problems

• 2406. Divide Intervals Into Minimum Number of Groups – greedy + heap on intervals
• 253. Meeting Rooms II – min-heap scheduling
• 435. Non-overlapping Intervals – greedy interval scheduling
• 1235. Maximum Profit in Job Scheduling – DP interval scheduling

Template Reference

• Heap

Examples

Example 1:

Input: n = 7
Output: [[0,0,0,null,null,0,0,null,null,0,0],
         [0,0,0,null,null,0,0,0,0],
         [0,0,0,0,0,0,0],
         [0,0,0,0,0,null,null,null,null,0,0],
         [0,0,0,0,0,null,null,0,0]]
(5 distinct full binary trees)

Example 2:

Input: n = 3
Output: [[0,0,0]]
(Only one: root with two leaves)

Constraints

• 1 <= n <= 20

Thinking Process

Key Observation

A full binary tree has the property: every internal node has exactly 2 children. This means:

• n must be odd (each subtree adds 2 nodes at a time, plus the root)
• If n is even, no full binary tree exists

Recursive Structure

A full binary tree with n nodes has:

• 1 root node
• i nodes in the left subtree
• n - 1 - i nodes in the right subtree

where i is odd and ranges over 1, 3, 5, ..., n-2.

For each split, recursively generate all left trees and all right trees, then combine every pair.

Memoization

The same subproblem allPossibleFBT(k) may be called multiple times (e.g., both left and right subtrees can have the same size). Caching results avoids redundant computation.

Walk-through (n=5)

n=5: root + split remaining 4 nodes
  i=1: left=FBT(1)=[leaf], right=FBT(3)=[root+2leaves]
    → 1 tree
  i=3: left=FBT(3)=[root+2leaves], right=FBT(1)=[leaf]
    → 1 tree

Total: 2 full binary trees with 5 nodes

Solution: Recursive + Memoization – $O(2^{n/2})$

class Solution {
    public TreeNode[] allPossibleFBT(int n) {
        if (n % 2 == 0) return {}
        if (n == 1) return {new TreeNode(0)}
        if (memo.contains(n)) return memo[n];

        TreeNode[] rtn;
        for (int i = 1; i < n; i += 2) {
            var leftTree = allPossibleFBT(i);
            var rightTree = allPossibleFBT(n - 1 - i);
            for (auto l : leftTree) {
                for (auto r : rightTree) {
                    TreeNode root = new TreeNode(0);
                    root.left = l;
                    root.right = r;
                    rtn.add(root);
                }
            }
        }
        return memo[n] = rtn;
    }
    unordered_map<int, TreeNode[]> memo;
}

Time: $O(2^{n/2})$ – the number of full binary trees grows as Catalan numbers Space: $O(n \cdot 2^{n/2})$ – storing all trees in the memo

Key Details

Why i += 2? Both subtrees must be full binary trees, so both must have an odd number of nodes. Starting at 1 and stepping by 2 ensures i and n - 1 - i are both odd.

Why memoization helps: FBT(3) might be needed as a left subtree for FBT(7) in multiple splits, and also as a right subtree. Caching avoids regenerating the same trees.

Catalan numbers: The count of full binary trees with $n$ nodes (where $n = 2k+1$) is the $k$-th Catalan number: $C_k = \frac{1}{k+1}\binom{2k}{k}$.

Common Mistakes

• Not checking for even n (no full binary tree exists)
• Stepping i by 1 instead of 2 (generates invalid subtree sizes)
• Forgetting to create a new root for each (l, r) combination (sharing root nodes across trees corrupts the output)

Key Takeaways

• “Generate all structurally unique trees” = recursive decomposition by subtree sizes + memoization
• The odd-only constraint and step-by-2 iteration are specific to full binary trees
• Same pattern as LC 95 (Unique BSTs II) – split, recurse, combine all pairs

Related Problems

• 95. Unique Binary Search Trees II – generate all BSTs (similar recursive structure)
• 96. Unique Binary Search Trees – count Catalan numbers
• 241. Different Ways to Add Parentheses – recursive split + combine pattern
• 108. Convert Sorted Array to BST – tree construction

Template Reference

• Trees
• DP

Examples

Example 1:

Input: nums = [18,43,36,13,7]
Output: 54
Explanation:
  digitSum(18) = 9, digitSum(36) = 9
  18 + 36 = 54 is the maximum pair with equal digit sums.

Example 2:

Input: nums = [10,12,19,14]
Output: -1
Explanation: No two numbers share the same digit sum.

Constraints

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^9

Thinking Process

To maximize the sum of a pair with equal digit sums, we want the two largest numbers in each digit-sum group.

Key Insight

We don’t need to store all numbers per group – just the largest so far. As we scan, for each number:

1. Compute its digit sum
2. If we’ve seen a number with the same digit sum, try pairing with the best one
3. Update the best for this digit sum

This is the “best seen so far” pattern – same idea as tracking the min price in Best Time to Buy and Sell Stock.

Walk-through

nums = [18, 43, 36, 13, 7]

x=18: digitSum=9,  best[9]=0  → no pair, best[9]=18
x=43: digitSum=7,  best[7]=0  → no pair, best[7]=43
x=36: digitSum=9,  best[9]=18 → pair: 18+36=54, rtn=54, best[9]=36
x=13: digitSum=4,  best[4]=0  → no pair, best[4]=13
x=7:  digitSum=7,  best[7]=43 → pair: 43+7=50, rtn=max(54,50)=54, best[7]=43

Answer: 54 ✓

Why best Array of Size 100?

Max digit sum occurs for 999,999,999 = $9 \times 9 = 81$. An array of size 100 covers all possible digit sums with margin.

Solution: Greedy (Best Seen So Far) – $O(n)$

class Solution {
    public int maximumSum(int[] nums) {
        int[] best = new int[100];
        int rtn = -1;
        for (int x : nums) {
            int s = digitSum(x);
            if (best[s] > 0) {
                rtn = Math.max(rtn, best[s] + x);
            }
            best[s] = Math.max(best[s], x);
        }
        return rtn;
    }
    int digitSum(int x) {
        int s = 0;
        while (x) {
            s += x % 10;
            x /= 10;
        }
        return s;
    }
}

Time: $O(n \cdot d)$ where $d$ = number of digits (at most 10) $\approx O(n)$ Space: $O(1)$ – fixed-size array of 100

Common Mistakes

• Storing all numbers per group and sorting (works but $O(n \log n)$ instead of $O(n)$)
• Forgetting to return -1 when no valid pair exists
• Updating best[s] before checking the pair (would pair a number with itself)

Key Takeaways

• “Best pair in a group” = track the best seen so far per group, check pair on each new element
• Using a fixed-size array instead of a hash map leverages the bounded digit-sum range for better constants
• The “update after pairing” order is critical – pair with the old best, then potentially replace it

Related Problems

• 1. Two Sum – pair finding with hash map
• 121. Best Time to Buy and Sell Stock – “best seen so far” pattern
• 49. Group Anagrams – grouping by canonical key
• 242. Valid Anagram – digit/character frequency

Template Reference

• Arrays & Strings