70. Climbing Stairs

CLAUDE.md

@@ -35,9 +35,14 @@ src/test/java/codes/yam/leetcode/{problemslug}/
 
 Each test file uses `@MethodSource("fully.qualified.TestCases#cases")` to share test data.
 
+**When to use `@ValueSource` vs `@MethodSource`:** Use `@ValueSource` for single-argument problems with groupable
+outcomes (e.g., boolean results — group inputs by true/false). Use `@MethodSource` with `TestCases` when each input has
+a distinct expected output (e.g., `climbStairs(3) → 3`).
+
 ## Code Conventions
 
-**Solution classes** are package-scoped (not `public`), use prefix naming (`Solution`, `SolutionNaive`, `SolutionDp`, etc.), and use HTML-formatted Javadoc:
+**Solution classes** are package-scoped (not `public`), use prefix naming (`Solution`, `SolutionNaive`, `SolutionDp`,
+etc.), and use HTML-formatted Javadoc:
 
 ```java
 /**

README.md

@@ -10,6 +10,7 @@ My LeetCode solutions in Java, focused on clean code and optimal algorithms.
 |------|-----------------------------------------------------------------------------------------------------------------------|------------|-------------------|--------|
 | 1    | [Two Sum](https://leetcode.com/problems/two-sum/)                                                                     | Easy       | `O(n log n)`      | `O(n)` |
 | 9    | [Palindrome Number](https://leetcode.com/problems/palindrome-number/)                                                 | Easy       | `O(log10(n) / 2)` | `O(1)` |
+| 70   | [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/)                                                     | Easy       | `O(n)`            | `O(1)` |
 | 1653 | [Minimum Deletions to Make String Balanced](https://leetcode.com/problems/minimum-deletions-to-make-string-balanced/) | Medium     | `O(n)`            | `O(1)` |
 
 ## Project Structure
@@ -29,7 +30,8 @@ src/test/java/codes/yam/leetcode/{problem-slug}/
 ```
 
 When a problem has multiple solution approaches, each gets its own `Solution*.java` class. `Solution.java` is always the
-optimal/final version. The progression is documented in `package-info.java`. Test data lives in a shared `TestCases.java`,
+optimal/final version. The progression is documented in `package-info.java`. Test data lives in a shared
+`TestCases.java`,
 and each solution has its own test file using `@MethodSource` to reference it.
 
 ## Commands
@@ -51,7 +53,8 @@ Right-click `src/test/java/codes/yam/leetcode/` → **New → Package** → `pro
 
 Start with LeetCode's example cases plus a few edge cases (aim for 3–5 per behavior):
 
-**For single-arg problems** — use `@ValueSource`, grouped by expected outcome:
+**For single-argument problems with groupable outcomes** (e.g., boolean results — group inputs by true/false) — use
+`@ValueSource`:
 
 ```java
 class SolutionTest {
@@ -71,7 +74,7 @@ class SolutionTest {
 }
 ```
 
-**For multi-arg problems** — use `@MethodSource`:
+**When each input has a distinct expected output** (e.g., `climbStairs(3) → 3`) — use `@MethodSource` with `TestCases`:
 
 ```java
 class SolutionTest {

src/main/java/codes/yam/leetcode/climbingstairs/NOTES.md

@@ -0,0 +1,61 @@
+# Recursion to DP: Step by Step
+
+## Starting point: your memoized solution
+
+```java
+int rec(int n) {
+    if (n == 1) return 1;
+    if (n == 2) return 2;
+    if (memo[n] != 0) return memo[n];
+    memo[n] = rec(n - 1) + rec(n - 2);
+    return memo[n];
+}
+```
+
+## Steps to convert to bottom-up DP
+
+1. **Look at what the memo array stores.** Each `memo[i]` holds the answer for input `i`. That's your DP table.
+
+2. **Find the base cases.** These are the entries you can fill without recursion: `memo[1] = 1` and `memo[2] = 2`.
+
+3. **Find the recurrence.** Strip away the recursion and just look at the formula:
+   `memo[n] = memo[n - 1] + memo[n - 2]`.
+
+4. **Figure out the fill order.** `memo[i]` depends on `memo[i - 1]` and `memo[i - 2]` — both smaller. So fill from
+   small to large (3, 4, 5, ... n).
+
+5. **Write the loop.** Seed the base cases, then loop from 3 to n applying the recurrence.
+
+## Result
+
+```java
+int climbStairs(int n) {
+    if (n <= 2) return n;
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    dp[2] = 2;
+    for (int i = 3; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+}
+```
+
+## Bonus: space optimization
+
+Notice `dp[i]` only ever reads `dp[i - 1]` and `dp[i - 2]`. You don't need the whole array — just two variables.
+
+```java
+int climbStairs(int n) {
+    if (n <= 2) return n;
+    int prev2 = 1, prev1 = 2;
+    for (int i = 3; i <= n; i++) {
+        int curr = prev1 + prev2;
+        prev2 = prev1;
+        prev1 = curr;
+    }
+    return prev1;
+}
+```
+
+This drops space from O(n) to O(1).

src/main/java/codes/yam/leetcode/climbingstairs/Solution.java

@@ -0,0 +1,27 @@
+package codes.yam.leetcode.climbingstairs;
+
+/**
+ * Solution for the <b>Climbing Stairs</b> problem.
+ *
+ * <p>Optimizes {@code SolutionDp} by replacing the DP array with two rolling variables.
+ *
+ * <ul>
+ *   <li><b>Time Complexity:</b> <code>O(n)</code>
+ *   <li><b>Space Complexity:</b> <code>O(1)</code>
+ * </ul>
+ */
+class Solution {
+  int climbStairs(int n) {
+    if (n == 1) return 1;
+    if (n == 2) return 2;
+    int a = 1;
+    int b = 2;
+    int c = a + b;
+    for (int i = 3; i <= n; i++) {
+      c = a + b;
+      a = b;
+      b = c;
+    }
+    return c;
+  }
+}

src/main/java/codes/yam/leetcode/climbingstairs/SolutionDp.java

@@ -0,0 +1,22 @@
+package codes.yam.leetcode.climbingstairs;
+
+/**
+ * Solution for the <b>Climbing Stairs</b> problem.
+ *
+ * <ul>
+ *   <li><b>Time Complexity:</b> <code>O(n)</code>
+ *   <li><b>Space Complexity:</b> <code>O(n)</code>
+ * </ul>
+ */
+class SolutionDp {
+  int climbStairs(int n) {
+    if (n <= 2) return n;
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    dp[2] = 2;
+    for (int i = 3; i <= n; i++) {
+      dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+  }
+}

src/main/java/codes/yam/leetcode/climbingstairs/SolutionMemoized.java

@@ -0,0 +1,27 @@
+package codes.yam.leetcode.climbingstairs;
+
+/**
+ * Solution for the <b>Climbing Stairs</b> problem.
+ *
+ * <ul>
+ *   <li><b>Time Complexity:</b> <code>O(n)</code>
+ *   <li><b>Space Complexity:</b> <code>O(n)</code>
+ * </ul>
+ */
+class SolutionMemoized {
+  int[] memo;
+
+  int rec(int n) {
+    if (n == 1) return 1;
+    if (n == 2) return 2;
+    if (memo[n] == 0) {
+      memo[n] = rec(n - 1) + rec(n - 2);
+    }
+    return memo[n];
+  }
+
+  int climbStairs(int n) {
+    memo = new int[n + 1];
+    return rec(n);
+  }
+}

src/main/java/codes/yam/leetcode/climbingstairs/SolutionRecursive.java

@@ -0,0 +1,17 @@
+package codes.yam.leetcode.climbingstairs;
+
+/**
+ * Solution for the <b>Climbing Stairs</b> problem.
+ *
+ * <ul>
+ *   <li><b>Time Complexity:</b> <code>O(2^n)</code>
+ *   <li><b>Space Complexity:</b> <code>O(n)</code>
+ * </ul>
+ */
+class SolutionRecursive {
+  int climbStairs(int n) {
+    if (n == 1) return 1;
+    if (n == 2) return 2;
+    return climbStairs(n - 1) + climbStairs(n - 2);
+  }
+}

src/test/java/codes/yam/leetcode/climbingstairs/SolutionDpTest.java

@@ -0,0 +1,14 @@
+package codes.yam.leetcode.climbingstairs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class SolutionDpTest {
+  @ParameterizedTest
+  @MethodSource("codes.yam.leetcode.climbingstairs.TestCases#cases")
+  void climbStairs(int n, int expected) {
+    assertEquals(expected, new SolutionDp().climbStairs(n));
+  }
+}

src/test/java/codes/yam/leetcode/climbingstairs/SolutionMemoizedTest.java

@@ -0,0 +1,14 @@
+package codes.yam.leetcode.climbingstairs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class SolutionMemoizedTest {
+  @ParameterizedTest
+  @MethodSource("codes.yam.leetcode.climbingstairs.TestCases#cases")
+  void climbStairs(int n, int expected) {
+    assertEquals(expected, new SolutionMemoized().climbStairs(n));
+  }
+}

src/test/java/codes/yam/leetcode/climbingstairs/SolutionRecursiveTest.java

@@ -0,0 +1,14 @@
+package codes.yam.leetcode.climbingstairs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class SolutionRecursiveTest {
+  @ParameterizedTest
+  @MethodSource("codes.yam.leetcode.climbingstairs.TestCases#cases")
+  void climbStairs(int n, int expected) {
+    assertEquals(expected, new SolutionRecursive().climbStairs(n));
+  }
+}

src/test/java/codes/yam/leetcode/climbingstairs/SolutionTest.java

@@ -0,0 +1,14 @@
+package codes.yam.leetcode.climbingstairs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class SolutionTest {
+  @ParameterizedTest
+  @MethodSource("codes.yam.leetcode.climbingstairs.TestCases#cases")
+  void climbStairs(int n, int expected) {
+    assertEquals(expected, new Solution().climbStairs(n));
+  }
+}

src/test/java/codes/yam/leetcode/climbingstairs/TestCases.java

@@ -0,0 +1,11 @@
+package codes.yam.leetcode.climbingstairs;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.provider.Arguments;
+
+@SuppressWarnings("unused")
+class TestCases {
+  static Stream<Arguments> cases() {
+    return Stream.of(Arguments.of(2, 2), Arguments.of(3, 3));
+  }
+}