Recursion & Backtracking

int digitSum(int n) {
    if (n == 0) return 0;          // base case
    return (n % 10) + digitSum(n / 10); // last digit + rest
}

// Dry run: digitSum(1234)
// = 4 + digitSum(123)
//   = 4 + 3 + digitSum(12)
//     = 4 + 3 + 2 + digitSum(1)
//       = 4 + 3 + 2 + 1 + digitSum(0)
//         = 4+3+2+1+0 = 10 ✓

int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2); // O(2ⁿ) — recomputes same values!
}

int[] memo = new int[101];
Arrays.fill(memo, -1);

int fib(int n) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n]; // already computed!
    memo[n] = fib(n-1) + fib(n-2);
    return memo[n];
}
// Time: O(n) — each subproblem solved once
// Space: O(n) — memo array + O(n) call stack

int fib(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        int c = a + b; a = b; b = c; // slide the window forward
    }
    return b;
}
// Time: O(n), Space: O(1) — best solution!

List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> result = new ArrayList<>();
    backtrack(nums, 0, new ArrayList<>(), result);
    return result;
}

void backtrack(int[] nums, int idx, List<Integer> cur,
               List<List<Integer>> res) {
    res.add(new ArrayList<>(cur));    // add current subset ALWAYS
    for (int i = idx; i < nums.length; i++) {
        cur.add(nums[i]);              // INCLUDE nums[i]
        backtrack(nums, i+1, cur, res); // explore with it
        cur.remove(cur.size()-1);      // BACKTRACK (exclude)
    }
}
// Time: O(2ⁿ × n) — 2ⁿ subsets, each takes O(n) to copy
// Space: O(n) — max recursion depth n

List<List<Integer>> combinationSum(int[] candidates, int target) {
    Arrays.sort(candidates); // ← enables early termination!
    List<List<Integer>> res = new ArrayList<>();
    backtrack(candidates, 0, target, new ArrayList<>(), res);
    return res;
}

void backtrack(int[] cands, int start, int remaining,
               List<Integer> cur, List<List<Integer>> res) {
    if (remaining == 0) { res.add(new ArrayList<>(cur)); return; }

    for (int i = start; i < cands.length; i++) {
        // PRUNING: sorted array → if cands[i] > remaining, all later are too
        if (cands[i] > remaining) break; // ← prune entire branch!

        cur.add(cands[i]);
        backtrack(cands, i, remaining - cands[i], cur, res); // i not i+1 (reuse!)
        cur.remove(cur.size()-1); // backtrack
    }
}

boolean exist(char[][] board, String word) {
    int m = board.length, n = board[0].length;
    for (int r = 0; r < m; r++)
        for (int c = 0; c < n; c++)
            if (dfs(board, word, r, c, 0)) return true; // try every start
    return false;
}

boolean dfs(char[][] board, String word, int r, int c, int idx) {
    if (idx == word.length()) return true;  // all chars matched!

    // PRUNE: out of bounds or wrong character or already visited
    if (r < 0 || r >= board.length || c < 0 || c >= board[0].length
        || board[r][c] != word.charAt(idx)) return false;

    char temp = board[r][c];
    board[r][c] = '#';  // MARK visited (in-place, no extra visited array!)

    boolean found = dfs(board,word,r+1,c,idx+1) // down
                 || dfs(board,word,r-1,c,idx+1) // up
                 || dfs(board,word,r,c+1,idx+1) // right
                 || dfs(board,word,r,c-1,idx+1); // left

    board[r][c] = temp;  // BACKTRACK: restore cell
    return found;
}
// Time: O(m×n × 4^L) where L = word length
// Space: O(L) — recursion depth = word length

// Approach 1: Naive Recursion — O(2ⁿ) ❌ TLE for large n
int climbStairs_naive(int n) {
    if (n <= 1) return 1;
    return climbStairs_naive(n - 1) + climbStairs_naive(n - 2);
}

// Approach 2: Memoization — O(n) time, O(n) space
int climbStairs_memo(int n, int[] memo) {
    if (n <= 1) return 1;
    if (memo[n] != 0) return memo[n];  // cache hit!
    memo[n] = climbStairs_memo(n-1, memo) + climbStairs_memo(n-2, memo);
    return memo[n];
}

// Approach 3: Iterative DP — O(n) time, O(1) space ✅
int climbStairs(int n) {
    if (n <= 1) return 1;
    int prev2 = 1, prev1 = 1;
    for (int i = 2; i <= n; i++) {
        int curr = prev1 + prev2;
        prev2 = prev1;
        prev1 = curr;
    }
    return prev1;
}

// Dry run: climbStairs(5)
// i=2: curr=1+1=2, prev2=1, prev1=2
// i=3: curr=2+1=3, prev2=2, prev1=3
// i=4: curr=3+2=5, prev2=3, prev1=5
// i=5: curr=5+3=8, prev2=5, prev1=8
// Return 8 ✓

List<String> generateParenthesis(int n) {
    List<String> result = new ArrayList<>();
    backtrack(result, new StringBuilder(), 0, 0, n);
    return result;
}

void backtrack(List<String> res, StringBuilder sb, int open, int close, int n) {
    if (sb.length() == 2 * n) {     // base case: used all n pairs
        res.add(sb.toString());
        return;
    }
    if (open < n) {               // can still open?
        sb.append('(');
        backtrack(res, sb, open + 1, close, n);
        sb.deleteCharAt(sb.length() - 1);  // ← BACKTRACK
    }
    if (close < open) {            // can close? (only if close < open)
        sb.append(')');
        backtrack(res, sb, open, close + 1, n);
        sb.deleteCharAt(sb.length() - 1);  // ← BACKTRACK
    }
}

// Recursion tree for n=2:
//              ""
//             /
//           "("
//          /      \
//       "(("      "()"
//       /           \
//     "(()"        "()(
//      /              \
//    "(())"         "()()"
//  [VALID]         [VALID]

List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> result = new ArrayList<>();
    backtrack(nums, 0, result);
    return result;
}

void backtrack(int[] nums, int idx, List<List<Integer>> res) {
    if (idx == nums.length) {                  // all positions fixed
        List<Integer> perm = new ArrayList<>();
        for (int n : nums) perm.add(n);
        res.add(perm);                            // add COPY
        return;
    }
    for (int i = idx; i < nums.length; i++) {
        swap(nums, idx, i);                       // choose
        backtrack(nums, idx + 1, res);             // explore
        swap(nums, idx, i);                       // unchoose
    }
}

void swap(int[] a, int i, int j) {
    int t = a[i]; a[i] = a[j]; a[j] = t;
}

// Dry run: [1, 2, 3], idx=0
// i=0: swap(0,0) → [1,2,3], recurse idx=1
//   i=1: swap(1,1) → [1,2,3], recurse idx=2
//     i=2: swap(2,2) → [1,2,3] → ADD [1,2,3] ✓
//   i=2: swap(1,2) → [1,3,2], recurse idx=2
//     → ADD [1,3,2] ✓, swap back → [1,2,3]
// i=1: swap(0,1) → [2,1,3], recurse idx=1
//   → generates [2,1,3] and [2,3,1]
// i=2: swap(0,2) → [3,2,1], recurse idx=1
//   → generates [3,2,1] and [3,1,2]

List<List<String>> solveNQueens(int n) {
    List<List<String>> result = new ArrayList<>();
    char[][] board = new char[n][n];
    for (char[] row : board) Arrays.fill(row, '.');

    Set<Integer> cols = new HashSet<>();
    Set<Integer> diag1 = new HashSet<>();  // row - col
    Set<Integer> diag2 = new HashSet<>();  // row + col

    solve(board, 0, cols, diag1, diag2, result);
    return result;
}

void solve(char[][] board, int row,
           Set<Integer> cols, Set<Integer> d1, Set<Integer> d2,
           List<List<String>> res) {
    if (row == board.length) {
        res.add(construct(board));     // found valid placement!
        return;
    }
    for (int col = 0; col < board.length; col++) {
        if (cols.contains(col) || d1.contains(row-col) || d2.contains(row+col))
            continue;              // pruned! O(1) check

        board[row][col] = 'Q';      // choose
        cols.add(col); d1.add(row-col); d2.add(row+col);

        solve(board, row+1, cols, d1, d2, res);  // explore

        board[row][col] = '.';      // unchoose (backtrack)
        cols.remove(col); d1.remove(row-col); d2.remove(row+col);
    }
}

String[] map = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};

List<String> letterCombinations(String digits) {
    List<String> result = new ArrayList<>();
    if (digits.isEmpty()) return result;
    backtrack(digits, 0, new StringBuilder(), result);
    return result;
}

void backtrack(String digits, int idx, StringBuilder sb, List<String> res) {
    if (idx == digits.length()) {
        res.add(sb.toString());   // used all digits → complete combo
        return;
    }
    String letters = map[digits.charAt(idx) - '0'];
    for (char c : letters.toCharArray()) {
        sb.append(c);             // choose
        backtrack(digits, idx + 1, sb, res);  // explore
        sb.deleteCharAt(sb.length() - 1);   // unchoose
    }
}

// Dry run: digits = "23"
// idx=0, digit='2', letters="abc"
//   c='a': sb="a", recurse idx=1
//     digit='3', letters="def"
//       c='d': sb="ad" → ADD "ad", remove 'd' → sb="a"
//       c='e': sb="ae" → ADD "ae", remove 'e' → sb="a"
//       c='f': sb="af" → ADD "af", remove 'f' → sb="a"
//     remove 'a' → sb=""
//   c='b': sb="b", recurse → "bd","be","bf"
//   c='c': sb="c", recurse → "cd","ce","cf"
// Total: 9 combinations ✓