solve problem Min Cost Climbing Stairs

Author: P-ppc

README.md

@@ -145,6 +145,7 @@ All solutions will be accepted!
 |724|[Find Pivot Index](https://leetcode-cn.com/problems/find-pivot-index/description/)|[java/py/js](./algorithms/FindPivotIndex)|Easy|
 |53|[Maximum Subarray](https://leetcode-cn.com/problems/maximum-subarray/description/)|[java/py/js](./algorithms/MaximumSubarray)|Easy|
 |543|[Diameter Of Binary](https://leetcode-cn.com/problems/diameter-of-binary-tree/description/)|[java/py/js](./algorithms/DiameterOfBinary)|Easy|
+|746|[Min Cost Climbing Stairs](https://leetcode-cn.com/problems/min-cost-climbing-stairs/description/)|[java/py/js](./algorithms/MinCostClimbingStairs)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/MinCostClimbingStairs/README.md

@@ -0,0 +1,16 @@
+# Min Cost Climbing Stairs
+This problem is easy to solve by dynamic programming, the recursion solution is like below:
+```
+class Solution(object):
+    def minCostClimbingStairs(self, cost):
+        """
+        :type cost: List[int]
+        :rtype: int
+        """        
+        if len(cost) < 2:
+            return 0
+        elif len(cost) == 2:
+            return min(cost[0], cost[1])
+        else:
+            return min(self.minCostClimbingStairs(cost[:-2]) + cost[-2], self.minCostClimbingStairs(cost[:-1]) + cost[-1])
+```

algorithms/MinCostClimbingStairs/Solution.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int minCostClimbingStairs(int[] cost) {
+        List<Integer> minCosts = new ArrayList<Integer>();
+        
+        for (int c : cost) {
+            int size = minCosts.size();
+            
+            if (size < 2) {
+                minCosts.add(c);
+            } else {
+                minCosts.add(c + Math.min(minCosts.get(size - 2), minCosts.get(size - 1)));
+            }
+        }
+        int size = minCosts.size();
+        return size < 2 ? 0 : Math.min(minCosts.get(size - 2), minCosts.get(size - 1));
+    }
+}

algorithms/MinCostClimbingStairs/solution.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minCostClimbingStairs = function(cost) {
+    let minCosts = []
+    
+    cost.forEach(c => {
+        let length = minCosts.length
+        if (length < 2) {
+            minCosts.push(c)
+        } else {
+            minCosts.push(c + Math.min(minCosts[length - 2], minCosts[length - 1]))
+        }
+    })
+    
+    let length = minCosts.length
+    return length < 2 ? 0 : Math.min(minCosts[length - 2], minCosts[length - 1])
+};

algorithms/MinCostClimbingStairs/solution.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def minCostClimbingStairs(self, cost):
+        """
+        :type cost: List[int]
+        :rtype: int
+        """
+        # the min cost of every stair
+        min_costs = []
+        
+        for c in cost:
+            if len(min_costs) < 2:
+                min_costs.append(c)
+            else:
+                min_costs.append(c + min(min_costs[-2], min_costs[-1]))
+        
+        return 0 if len(min_costs) < 2 else min(min_costs[-2], min_costs[-1])