746. Min Cost Climbing Stairs

README.md

@@ -6,12 +6,25 @@ My LeetCode solutions in Java, focused on clean code and optimal algorithms.
 
 ## Solutions
 
-| #    | Problem                                                                                                               | Difficulty | Time              | Space  |
-|------|-----------------------------------------------------------------------------------------------------------------------|------------|-------------------|--------|
-| 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)` |
+| #*              | Problem                                                                                                                          | Difficulty | Time              | Space  |
+|-----------------|----------------------------------------------------------------------------------------------------------------------------------|------------|-------------------|--------|
+| [1][lc-1]       | [Two Sum](src/main/java/codes/yam/leetcode/twosum/Solution.java)                                                                 | Easy       | `O(n log n)`      | `O(n)` |
+| [9][lc-9]       | [Palindrome Number](src/main/java/codes/yam/leetcode/palindromenumber/Solution.java)                                             | Easy       | `O(log10(n) / 2)` | `O(1)` |
+| [70][lc-70]     | [Climbing Stairs](src/main/java/codes/yam/leetcode/climbingstairs/Solution.java)                                                 | Easy       | `O(n)`            | `O(1)` |
+| [746][lc-746]   | [Min Cost Climbing Stairs](src/main/java/codes/yam/leetcode/mincostclimbingstairs/Solution.java)                                 | Easy       | `O(n)`            | `O(1)` |
+| [1653][lc-1653] | [Minimum Deletions to Make String Balanced](src/main/java/codes/yam/leetcode/minimumdeletionstomakestringbalanced/Solution.java) | Medium     | `O(n)`            | `O(1)` |
+
+<sup>*Problem numbers link to LeetCode; problem names link to solution source.</sup>
+
+[lc-1]: https://leetcode.com/problems/two-sum/
+
+[lc-9]: https://leetcode.com/problems/palindrome-number/
+
+[lc-70]: https://leetcode.com/problems/climbing-stairs/
+
+[lc-746]: https://leetcode.com/problems/min-cost-climbing-stairs/
+
+[lc-1653]: https://leetcode.com/problems/minimum-deletions-to-make-string-balanced/
 
 ## Project Structure
 

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

@@ -0,0 +1,24 @@
+package codes.yam.leetcode.mincostclimbingstairs;
+
+/**
+ * Solution for the <b>Min Cost 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 minCostClimbingStairs(int[] cost) {
+    int a = 0;
+    int b = 0;
+    for (int i = 2; i <= cost.length; i++) {
+      int c = Math.min(a + cost[i - 2], b + cost[i - 1]);
+      a = b;
+      b = c;
+    }
+    return b;
+  }
+}

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

@@ -0,0 +1,22 @@
+package codes.yam.leetcode.mincostclimbingstairs;
+
+/**
+ * Solution for the <b>Min Cost 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 minCostClimbingStairs(int[] cost) {
+    int n = cost.length;
+    int[] dp = new int[n + 1];
+    dp[0] = 0;
+    dp[1] = 0;
+    for (int i = 2; i <= n; i++) {
+      dp[i] = Math.min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1]);
+    }
+    return dp[n];
+  }
+}

src/main/java/codes/yam/leetcode/mincostclimbingstairs/package-info.java

@@ -0,0 +1,18 @@
+/**
+ * Solutions for the "Min Cost Climbing Stairs" problem on LeetCode.
+ *
+ * <ul>
+ *   <li><b>Slug:</b> <code>min-cost-climbing-stairs</code>
+ *   <li><b>Difficulty:</b> Easy
+ * </ul>
+ *
+ * <p><b>Solution progression:</b>
+ *
+ * <ol>
+ *   <li>{@code SolutionDp} — Bottom-up DP, <code>O(n)</code> time, <code>O(n)</code> space
+ *   <li>{@code Solution} — Space-optimized DP, <code>O(n)</code> time, <code>O(1)</code> space
+ * </ol>
+ *
+ * @see <a href="https://leetcode.com/problems/min-cost-climbing-stairs/">Problem Link</a>
+ */
+package codes.yam.leetcode.mincostclimbingstairs;

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

@@ -0,0 +1,14 @@
+package codes.yam.leetcode.mincostclimbingstairs;
+
+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.mincostclimbingstairs.TestCases#cases")
+  void minCostClimbingStairs(int[] cost, int expected) {
+    assertEquals(expected, new SolutionDp().minCostClimbingStairs(cost));
+  }
+}

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

@@ -0,0 +1,14 @@
+package codes.yam.leetcode.mincostclimbingstairs;
+
+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.mincostclimbingstairs.TestCases#cases")
+  void minCostClimbingStairs(int[] cost, int expected) {
+    assertEquals(expected, new Solution().minCostClimbingStairs(cost));
+  }
+}

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

@@ -0,0 +1,13 @@
+package codes.yam.leetcode.mincostclimbingstairs;
+
+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(new int[] {10, 15, 20}, 15),
+        Arguments.of(new int[] {1, 100, 1, 1, 1, 100, 1, 1, 100, 1}, 6));
+  }
+}