Min cost climbing stairs

Author: volodimyr

746.min_cost_climbing_stairs/cost.py

@@ -0,0 +1,55 @@
+# 746. Min cost climbing stairs
+# Topics: 'Array', 'Dynamic Programming'
+
+# You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.
+
+# You can either start from the step with index 0, or the step with index 1.
+
+# Return the minimum cost to reach the top of the floor.
+
+ 
+
+# Example 1:
+
+# Input: cost = [10,15,20]
+# Output: 15
+# Explanation: You will start at index 1.
+# - Pay 15 and climb two steps to reach the top.
+# The total cost is 15.
+
+# Example 2:
+
+# Input: cost = [1,100,1,1,1,100,1,1,100,1]
+# Output: 6
+# Explanation: You will start at index 0.
+# - Pay 1 and climb two steps to reach index 2.
+# - Pay 1 and climb two steps to reach index 4.
+# - Pay 1 and climb two steps to reach index 6.
+# - Pay 1 and climb one step to reach index 7.
+# - Pay 1 and climb two steps to reach index 9.
+# - Pay 1 and climb one step to reach the top.
+# The total cost is 6.
+
+ 
+
+# Constraints:
+
+#     2 <= cost.length <= 1000
+#     0 <= cost[i] <= 999
+
+from typing import List
+
+
+class Solution:
+    def minCostClimbingStairs(self, cost: List[int]) -> int:
+        memo = [-1]*(len(cost)+1)
+        return min(self.climb(0, cost, memo), self.climb(1, cost, memo))
+    
+    def climb(self, i: int, cost: List[int], memo: List[int]) -> int:
+        if i < len(cost):
+            if memo[i] != -1:
+                return memo[i]
+            memo[i] = cost[i] + min(self.climb(i+1, cost, memo), self.climb(i+2, cost, memo))
+            return memo[i]
+        else:
+            return 0

746.min_cost_climbing_stairs/test_cost.py

@@ -0,0 +1,58 @@
+import unittest
+from cost import Solution
+
+class TestMinCostClimbingStairs(unittest.TestCase):
+    def setUp(self):
+        self.s = Solution()
+
+    def test_example_1(self):
+        cost = [10, 15, 20]
+        expected = 15
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_example_2(self):
+        cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
+        expected = 6
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_two_elements_take_cheapest(self):
+        cost = [5, 3]
+        expected = 3
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_two_elements_equal(self):
+        cost = [7, 7]
+        expected = 7
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_increasing_costs(self):
+        cost = [1, 2, 3, 4, 5]
+        # Best: 2 + 4 = 6
+        expected = 6
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_decreasing_costs(self):
+        cost = [10, 8, 6, 4, 2]
+        # Best: start 1 → skip → 3 → skip → top = 8 + 4 = 12
+        expected = 12
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_zero_costs(self):
+        cost = [0, 0, 0, 0]
+        expected = 0
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_large_values(self):
+        cost = [999] * 20
+        # Always just pick any consistent route: all same → 999 * ceil(n/2)
+        expected = 999 * 10
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+    def test_single_step_zero_then_big(self):
+        cost = [0, 100, 0, 100, 0]
+        expected = 0
+        self.assertEqual(self.s.minCostClimbingStairs(cost), expected)
+
+
+if __name__ == "__main__":
+    unittest.main()