Add Python Interview Idioms cheat sheet and update README

Author: peterbonnesoeur

1-D_Dynamic_Programming/resume.md

@@ -1,250 +1,124 @@
-# 1-DD
+# 1-D Dynamic Programming
 
-**Dynamic Programming (DP)** is a powerful algorithmic technique for solving problems by breaking them down into overlapping subproblems. Each subproblem is solved only once, and its solution is stored (usually in a table or array) to avoid redundant computations. DP is especially effective for problems involving optimization, counting, and partitioning.
+**One-liner.** State indexed by **one** parameter (position / value / count); transition reuses smaller subproblems.
 
-### Key Concepts in Dynamic Programming
-
-1. **Optimal Substructure**: A problem exhibits optimal substructure if its optimal solution can be constructed from the optimal solutions of its subproblems.
-  
-2. **Overlapping Subproblems**: A problem has overlapping subproblems if it can be broken down into subproblems that are solved multiple times. DP is efficient for such problems because it avoids redundant calculations by storing results.
-
-3. **Memoization vs. Tabulation**:
-   - **Memoization**: A top-down approach where results of subproblems are stored as they are computed (usually with recursion and a cache).
-   - **Tabulation**: A bottom-up approach where solutions to subproblems are built iteratively, filling a table from smaller to larger subproblems.
-
----
-
-### Common Types of DP Problems
-
-1. **Fibonacci Sequence**
-2. **Knapsack Problems**
-3. **Longest Common Subsequence (LCS)**
-4. **Edit Distance**
-5. **Coin Change**
-6. **Partition Problem**
-7. **Minimum Path Sum**
-8. **Matrix Chain Multiplication**
-
-Let’s explore these with explanations, examples, and code.
-
----
-
-### 1. Fibonacci Sequence
-
-**Problem**: Find the nth Fibonacci number, where `Fib(n) = Fib(n-1) + Fib(n-2)` and `Fib(0) = 0`, `Fib(1) = 1`.
-
-**Recursive DP (Memoization)**:
-
-```python
-def fib_memo(n, memo={}):
-    if n in memo:
-        return memo[n]
-    if n <= 1:
-        return n
-    memo[n] = fib_memo(n-1, memo) + fib_memo(n-2, memo)
-    return memo[n]
-
-# Example usage
-print(fib_memo(10))  # Output: 55
+## Visual
 ```
+House Robber  nums = [2, 7, 9, 3, 1]
 
-**Iterative DP (Tabulation)**:
+  i:     0   1   2   3   4
+  nums:  2   7   9   3   1
+  dp:    2   7  11  11  12       dp[i] = max(dp[i-1], dp[i-2]+nums[i])
+              ↑↑↑              "skip i" vs "rob i + best up to i-2"
 
-```python
-def fib_tab(n):
-    if n <= 1:
-        return n
-    dp = [0, 1]
-    for i in range(2, n + 1):
-        dp.append(dp[i-1] + dp[i-2])
-    return dp[n]
-
-# Example usage
-print(fib_tab(10))  # Output: 55
-```
-
-**Time Complexity**: O(n) for both approaches.
-
----
-
-### 2. Knapsack Problem
-
-**Problem**: Given a list of items with weights and values, and a knapsack with a weight capacity `W`, maximize the value in the knapsack without exceeding `W`. Each item can only be included once (0/1 Knapsack).
+  Space-optimized: only prev2, prev1 kept → O(1) memory.
 
-**Solution Approach (Tabulation)**:
-- Use a DP table where `dp[i][j]` represents the maximum value achievable with the first `i` items and weight limit `j`.
-
-**Code Example**:
-
-```python
-def knapsack(weights, values, W):
-    n = len(weights)
-    dp = [[0] * (W + 1) for _ in range(n + 1)]
-
-    for i in range(1, n + 1):
-        for j in range(W + 1):
-            if weights[i-1] <= j:
-                dp[i][j] = max(dp[i-1][j], values[i-1] + dp[i-1][j - weights[i-1]])
-            else:
-                dp[i][j] = dp[i-1][j]
-
-    return dp[n][W]
-
-# Example usage
-weights = [1, 2, 3]
-values = [10, 15, 40]
-W = 5
-print(knapsack(weights, values, W))  # Output: 55
+Recursion tree without memo (Fibonacci-style):
+   f(5) ──┬── f(4) ──┬── f(3) ─── f(2) ─── f(1)
+          │          └── f(2) ──┘  ← recomputed
+          └── f(3) ─── f(2)        ← recomputed again
+   ⇒ memoize and the tree becomes a chain (O(n))
 ```
 
-**Time Complexity**: O(n * W), where `n` is the number of items and `W` is the knapsack capacity.
-
----
-
-### 3. Longest Common Subsequence (LCS)
-
-**Problem**: Given two strings, find the length of their longest common subsequence (a sequence of characters that appears in both strings in the same order).
-
-**Solution Approach (Tabulation)**:
-- Use a 2D DP table where `dp[i][j]` represents the length of the LCS for substrings of the first `i` characters of string `A` and the first `j` characters of string `B`.
-
-**Code Example**:
-
+## Mental model
+DP is **brute force with a notebook**: write down each subproblem the first time you solve it, never compute it twice. The mental jump from recursion to DP is realizing the recursion tree has *overlap*. In real systems this is exactly what memoization, build caches, incremental computation, and query plan caches do — same shape, different vocabulary.
+
+## Recognize it
+- "min / max / count of ways" over a sequence
+- "decisions per index", optimal substructure
+- problem feels like backtracking but you only need **a number**, not the solutions
+- overlapping subproblems (you'd recompute the same state in naive recursion)
+
+## Pick DP over...
+| Instead of | Use DP when |
+|---|---|
+| backtracking | you only need a count / min / max, not the solutions themselves |
+| greedy | a local choice can hurt later (e.g. coin change with weird denominations) |
+| math closed-form | recurrence doesn't simplify |
+| BFS | states have weights, not unit cost |
+
+## The 5-step recipe (do this on EVERY DP problem)
+1. **State** — what does `dp[i]` mean in one sentence? (write it down)
+2. **Transition** — how do `dp[i]` and smaller states relate? (the recurrence)
+3. **Base case** — what's `dp[0]` (and maybe `dp[1]`)?
+4. **Order** — bottom-up (tabulation) or top-down (memo)?
+5. **Answer** — is it `dp[n]`, `dp[n-1]`, `max(dp)`, …?
+
+## Top-down (memoization)
 ```python
-def lcs(A, B):
-    m, n = len(A), len(B)
-    dp = [[0] * (n + 1) for _ in range(m + 1)]
-
-    for i in range(1, m + 1):
-        for j in range(1, n + 1):
-            if A[i-1] == B[j-1]:
-                dp[i][j] = dp[i-1][j-1] + 1
-            else:
-                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
-
-    return dp[m][n]
+from functools import cache
 
-# Example usage
-print(lcs("ABCBDAB", "BDCAB"))  # Output: 4
+@cache
+def f(i):
+    if i <= 0: return base(i)
+    return combine(f(i-1), f(i-2), ...)
 ```
 
-**Time Complexity**: O(m * n), where `m` and `n` are the lengths of the strings.
-
----
-
-### 4. Edit Distance
-
-**Problem**: Given two strings `A` and `B`, find the minimum number of operations required to convert `A` into `B`. Allowed operations are insertion, deletion, and substitution.
-
-**Solution Approach (Tabulation)**:
-- Use a 2D DP table where `dp[i][j]` represents the minimum edit distance between the first `i` characters of `A` and the first `j` characters of `B`.
-
-**Code Example**:
-
+## Bottom-up (tabulation)
 ```python
-def edit_distance(A, B):
-    m, n = len(A), len(B)
-    dp = [[0] * (n + 1) for _ in range(m + 1)]
-
-    for i in range(m + 1):
-        for j in range(n + 1):
-            if i == 0:
-                dp[i][j] = j
-            elif j == 0:
-                dp[i][j] = i
-            elif A[i-1] == B[j-1]:
-                dp[i][j] = dp[i-1][j-1]
-            else:
-                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
-
-    return dp[m][n]
-
-# Example usage
-print(edit_distance("sunday", "saturday"))  # Output: 3
+dp = [0] * (n + 1)
+dp[0] = base
+for i in range(1, n + 1):
+    dp[i] = recurrence(dp[i-1], dp[i-2], ...)
+return dp[n]
 ```
 
-**Time Complexity**: O(m * n).
-
----
-
-### 5. Coin Change
-
-**Problem**: Given an integer array `coins` representing coin denominations and an integer `amount`, find the minimum number of coins that make up `amount`.
-
-**Solution Approach (Tabulation)**:
-- Use a 1D DP array where `dp[i]` represents the minimum number of coins needed for amount `i`.
-
-**Code Example**:
-
+## Space-optimized (keep last-k window)
 ```python
-def coin_change(coins, amount):
-    dp = [float('inf')] * (amount + 1)
-    dp[0] = 0
+prev2, prev1 = base0, base1
+for i in range(2, n + 1):
+    cur = recurrence(prev1, prev2)
+    prev2, prev1 = prev1, cur
+return prev1
+```
 
-    for coin in coins:
-        for i in range(coin, amount + 1):
-            dp[i] = min(dp[i], dp[i - coin] + 1)
+## The 1-D pattern zoo
 
-    return dp[amount] if dp[amount] != float('inf') else -1
+**Fibonacci / Climbing stairs** — `dp[i] = dp[i-1] + dp[i-2]`.
 
-# Example usage
-print(coin_change([1, 2, 5], 11))  # Output: 3
-```
+**House Robber** — `dp[i] = max(dp[i-1], dp[i-2] + nums[i])`.
 
-**Time Complexity**: O(n * amount), where `n` is the number of coins.
+**House Robber II (circular)** — run rob on `nums[:-1]` and `nums[1:]`, take max.
 
----
+**Min cost climbing stairs** — `dp[i] = min(dp[i-1], dp[i-2]) + cost[i]`.
 
-### 6. Minimum Path Sum
+**Decode ways** — `dp[i] = (dp[i-1] if s[i] != '0') + (dp[i-2] if 10 ≤ int(s[i-1:i+1]) ≤ 26)`.
 
-**Problem**: Given a grid of non-negative integers, find a path from the top-left to the bottom-right that minimizes the sum of the numbers along the path. You can only move right or down.
+**Word break** — `dp[i] = any(dp[j] and s[j:i] in dict for j < i)`.
 
-**Solution Approach (Tabulation)**:
-- Use a 2D DP table where `dp[i][j]` represents the minimum path sum to reach cell `(i, j)`.
+**Coin change (min coins, unlimited)** — `dp[a] = min(dp[a - c] + 1 for c in coins)`; init `dp[0]=0`, others `inf`.
 
-**Code Example**:
+**Coin change 2 (count combinations)** — outer loop **coin**, inner loop **amount** (order matters for combinations not permutations!).
 
-```python
-def min_path_sum(grid):
-    m, n = len(grid), len(grid[0])
-    dp = [[0] * n for _ in range(m)]
-    dp[0][0] = grid[0][0]
-
-    for i in range(1, m):
-        dp[i][0] = dp[i-1][0] + grid[i][0]
-    for j in range(1, n):
-        dp[0][j] = dp[0][j-1] + grid[0][j]
-
-    for i in range(1, m):
-        for j in range(1, n):
-            dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
-
-    return dp[m-1][n-1]
-
-# Example usage
-grid = [
-  [1, 3, 1],
-  [1, 5, 1],
-  [4, 2, 1]
-]
-print(min_path_sum(grid))  # Output: 7
-```
+**Longest Increasing Subsequence (LIS)**:
+- O(n²): `dp[i] = 1 + max(dp[j] for j<i if nums[j] < nums[i], default=0)`.
+- O(n log n): `bisect_left` into a "tails" array — the array's **length** is the answer (its contents are not the actual LIS).
 
-**Time Complexity**: O(m * n), where `m` and `n` are the grid dimensions.
+**Partition equal subset sum** — subset-sum DP: `dp[s] = True if dp[s - num] OR dp[s]`. Iterate amounts **backward** to avoid reuse.
 
----
+**Maximum subarray (Kadane)** — `cur = max(x, cur + x)`; `best = max(best, cur)`.
 
-### Summary of Dynamic Programming
+**Maximum product subarray** — track `(min, max)` because negatives flip.
 
-| **Problem**           | **Approach**             | **
+## Edge cases
+- empty input — base case `dp[0] = 0` / `1` / problem-defined
+- single element — make sure transitions don't out-of-bounds index
+- `inf` sentinel for "unreachable" in min-DP (`coin change`); guard the final answer
+- coin change with no solution → return `-1` (check `dp[amount] == inf`)
+- LIS with duplicates: strict (`<`) vs non-strict (`≤`) → `bisect_left` vs `bisect_right`
+- maximum product with all negatives / containing zeros — Kadane's track-both fixes this
+- 0/1 vs unbounded knapsack — iterate amount **backward** for 0/1, **forward** for unbounded
 
-Complexity**   | **Explanation**                                  |
-|-----------------------|--------------------------|-------------------|--------------------------------------------------|
-| Fibonacci Sequence    | Memoization or Tabulation| O(n)             | Avoid redundant calculations for each Fib(n).    |
-| Knapsack              | Tabulation               | O(n * W)         | Maximize value without exceeding weight W.       |
-| Longest Common Subseq | Tabulation               | O(m * n)         | Finds the longest subsequence present in both.   |
-| Edit Distance         | Tabulation               | O(m * n)         | Transform one string to another with minimal ops.|
-| Coin Change           | Tabulation               | O(n * amount)    | Find min coins for given amount.                 |
-| Minimum Path Sum      | Tabulation               | O(m * n)         | Minimize the sum from top-left to bottom-right.  |
+## Complexity
+- Linear transitions: O(n) time, O(n) or O(1) space.
+- Knapsack-style: O(n · W).
+- LIS O(n log n) via patience sorting.
+- Coin change: O(amount · |coins|).
 
-Dynamic Programming is versatile for solving a wide variety of problems, especially those with overlapping subproblems and optimal substructure. Its efficiency often lies in converting exponential recursive problems to polynomial solutions.
+## Gotchas
+- **State definition vague** → recurrence will be wrong. Pin down what `dp[i]` means *exactly* (inclusive? ending here? up to here?).
+- For "ending at i" vs "up to i" — completely different recurrences for problems like max subarray.
+- Iteration order matters for 0/1 vs unbounded — flip it and you've changed the problem.
+- Use `@cache` (Python 3.9+) for trivial top-down, but watch out for unhashable args.
+- Initialize `inf` only for **min** problems; `-inf` or `0` for max/count. Wrong sentinel breaks everything.
+- LIS O(n log n) gives you the **length**, not the subsequence — reconstructing needs back-pointers.