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.

&nbsp;
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.


&nbsp;
Constraints:


	2 &lt;= cost.length &lt;= 1000
	0 &lt;= cost[i] &lt;= 999


class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        dp = cost[:2] + [0]*(n-2)
        for i in range(2, n):
            dp[i] = min(dp[i-1], dp[i-2]) + cost[i]
        return min(dp[-1], dp[-2])
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int a[] = new int[cost.length+1];
        a[0]=0;
        a[1]=0;
        
        for(int i=2;i<=cost.length;i++)
        {
            a[i]= Math.min(cost[i-1]+a[i-1], cost[i-2]+a[i-2]);
        }
        return a[cost.length];
    }
}
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        /* Minimize cost of steps, where you can take one or two steps.
           
           At each step, store the minimum of the current step plus the step previous
           or the step two previous. At the last step we can either take the last
           element or leave it off.
        */
        int n = cost.size();
        for(int i = 2; i < n; i++) {
            cost[i] = min(cost[i] + cost[i-2], cost[i] + cost[i-1]);    
        }
        
        return min(cost[n-1], cost[n-2]);
    }
};
var minCostClimbingStairs = function(cost) {
    //this array will be populated with the minimum cost of each step starting from the top
    let minCostArray = [];
    //append a 0 at end to represent reaching the 'top'
    minCostArray[cost.length] = 0;
    //append the last stair to the end of the array
    minCostArray[cost.length - 1] = cost[cost.length - 1];
    
    //starts at -2 the length since we already have two elements in our array
    for (let i = cost.length - 2; i > -1; i--) {
        //checks which minimum cost is lower and assigns the value at that index accordingly
        if (minCostArray[i + 1] < minCostArray[i + 2]) minCostArray[i] = cost[i] + minCostArray[i + 1];
        else minCostArray[i] = cost[i] + minCostArray[i + 2];
    }
    //checks which of the first two options is the lowest cost
    return minCostArray[0] > minCostArray[1] ? minCostArray[1] : minCostArray[0];
};
Min Cost Climbing Stairs