# Minimum cost to reach the top of the floor by climbing stairs

 `//Write Java code here `

public static int minCostClimbingStairs(int[] cost) {

//The idea is to start from 2nd index and find Min of 0th & 1st Index.

for(int i=2; i<cost.length; i++){
cost[i] += Math.min(cost[i-1] , cost[i-2]);
}

//Finally the Last and the Second Last Ele of Array will hold the cost
//So return the Min of both the cost

return Math.min(cost[cost.length-1], cost[cost.length-2]);
}

Examples:

```Input: a[] = { 16, 19, 10, 12, 18 }
Output: 31
Start from 19 and then move to 12.

Input: a[] = {2, 5, 3, 1, 7, 3, 4}
Output: 9
2->3->1->3```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Let dp[i] be the cost to climb the i-th staircase to from 0-th or 1-th step. Hence dp[i] = cost[i] + min(dp[i-1], dp[i-2]). Since dp[i-1] and dp[i-2] is needed to compute the cost of travelling from i-th step, a bottom-up approach can be used to solve the problem. The answer will be the minimum of cost of reaching n-1th stair and n-2th stair. Compute the dp[] array in bottom-up manner.
Below is the implementation of the above approach.

## C++

 `// C++ program to find the minimum ` `// cost required to reach the n-th floor ` `#include ` `using` `namespace` `std; ` ` `  `// function to find the minimum cost ` `// to reach N-th floor ` `int` `minimumCost(``int` `cost[], ``int` `n) ` `{ ` `    ``// declare an array ` `    ``int` `dp[n]; ` ` `  `    ``// base case ` `    ``if` `(n == 1) ` `        ``return` `cost[0]; ` ` `  `    ``// initially to climb till 0-th ` `    ``// or 1th stair ` `    ``dp[0] = cost[0]; ` `    ``dp[1] = cost[1]; ` ` `  `    ``// iterate for finding the cost ` `    ``for` `(``int` `i = 2; i < n; i++) { ` `        ``dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]; ` `    ``} ` ` `  `    ``// return the minimum ` `    ``return` `min(dp[n - 2], dp[n - 1]); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a[] = { 16, 19, 10, 12, 18 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` `    ``cout << minimumCost(a, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the  ` `// minimum cost required to ` `// reach the n-th floor ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `// function to find  ` `// the minimum cost ` `// to reach N-th floor ` `static` `int` `minimumCost(``int` `cost[],  ` `                       ``int` `n) ` `{ ` `    ``// declare an array ` `    ``int` `dp[] = ``new` `int``[n]; ` ` `  `    ``// base case ` `    ``if` `(n == ``1``) ` `        ``return` `cost[``0``]; ` ` `  `    ``// initially to  ` `    ``// climb till 0-th ` `    ``// or 1th stair ` `    ``dp[``0``] = cost[``0``]; ` `    ``dp[``1``] = cost[``1``]; ` ` `  `    ``// iterate for finding the cost ` `    ``for` `(``int` `i = ``2``; i < n; i++) ` `    ``{ ` `        ``dp[i] = Math.min(dp[i - ``1``],  ` `                         ``dp[i - ``2``]) + cost[i]; ` `    ``} ` ` `  `    ``// return the minimum ` `    ``return` `Math.min(dp[n - ``2``],  ` `                    ``dp[n - ``1``]); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `a[] = { ``16``, ``19``, ``10``, ``12``, ``18` `}; ` `    ``int` `n = a.length; ` `    ``System.out.print(minimumCost(a, n)); ` `} ` `} `

## Python 3

 `# Python 3 program to find  ` `# the minimum cost required  ` `# to reach the n-th floor ` ` `  `# function to find the minimum  ` `# cost to reach N-th floor ` `def` `minimumCost(cost, n): ` ` `  `    ``# declare an array ` `    ``dp ``=` `[``None``]``*``n ` ` `  `    ``# base case ` `    ``if` `n ``=``=` `1``: ` `        ``return` `cost[``0``] ` ` `  `    ``# initially to climb  ` `    ``# till 0-th or 1th stair ` `    ``dp[``0``] ``=` `cost[``0``] ` `    ``dp[``1``] ``=` `cost[``1``] ` ` `  `    ``# iterate for finding the cost ` `    ``for` `i ``in` `range``(``2``, n):  ` `        ``dp[i] ``=` `min``(dp[i ``-` `1``],  ` `                    ``dp[i ``-` `2``]) ``+` `cost[i] ` ` `  `    ``# return the minimum ` `    ``return` `min``(dp[n ``-` `2``], dp[n ``-` `1``]) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``a ``=` `[``16``, ``19``, ``10``, ``12``, ``18` `] ` `    ``n ``=` `len``(a) ` `    ``print``(minimumCost(a, n)) ` ` `  `# This code is contributed  ` `# by ChitraNayal `

## C#

 `// C# program to find the  ` `// minimum cost required to ` `// reach the n-th floor ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// function to find  ` `// the minimum cost ` `// to reach N-th floor ` `static` `int` `minimumCost(``int``[] cost,  ` `                       ``int` `n) ` `{ ` `    ``// declare an array ` `    ``int` `[]dp = ``new` `int``[n]; ` ` `  `    ``// base case ` `    ``if` `(n == 1) ` `        ``return` `cost[0]; ` ` `  `    ``// initially to  ` `    ``// climb till 0-th ` `    ``// or 1th stair ` `    ``dp[0] = cost[0]; ` `    ``dp[1] = cost[1]; ` ` `  `    ``// iterate for finding the cost ` `    ``for` `(``int` `i = 2; i < n; i++) ` `    ``{ ` `        ``dp[i] = Math.Min(dp[i - 1],  ` `                         ``dp[i - 2]) + cost[i]; ` `    ``} ` ` `  `    ``// return the minimum ` `    ``return` `Math.Min(dp[n - 2],  ` `                    ``dp[n - 1]); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]a = { 16, 19, 10, 12, 18 }; ` `    ``int` `n = a.Length; ` `    ``Console.WriteLine(minimumCost(a, n)); ` `} ` `} ` ` `  `// This code is contributed ` `// by Subhadeep `

## PHP

 ` `

Output:

```31
```

Time Complexity: O(N)
Auxiliary Space: O(N)

Space-optimized Approach: Instead of using dp[] array for memoizing the cost, use two variable dp1 and dp2. Since the cost of reaching the last two stairs are required only, use two variables and update them by swapping when one stair is climbed.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the minimum ` `// cost required to reach the n-th floor ` `// space-optimized solution ` `#include ` `using` `namespace` `std; ` ` `  `// function to find the minimum cost ` `// to reach N-th floor ` `int` `minimumCost(``int` `cost[], ``int` `n) ` `{ ` `    ``int` `dp1 = 0, dp2 = 0; ` ` `  `    ``// traverse till N-th stair ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``int` `dp0 = cost[i] + min(dp1, dp2); ` ` `  `        ``// update the last two stairs value ` `        ``dp2 = dp1; ` `        ``dp1 = dp0; ` `    ``} ` `    ``return` `min(dp1, dp2); ` `} ` `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a[] = { 2, 5, 3, 1, 7, 3, 4 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` `    ``cout << minimumCost(a, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the  ` `// minimum cost required to  ` `// reach the n-th floor  ` `// space-optimized solution ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `// function to find  ` `// the minimum cost ` `// to reach N-th floor ` `static` `int` `minimumCost(``int` `cost[], ``int` `n) ` `{ ` `    ``int` `dp1 = ``0``, dp2 = ``0``; ` ` `  `    ``// traverse till N-th stair ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``int` `dp0 = cost[i] +  ` `                  ``Math.min(dp1, dp2); ` ` `  `        ``// update the last  ` `        ``// two stairs value ` `        ``dp2 = dp1; ` `        ``dp1 = dp0; ` `    ``} ` `    ``return` `Math.min(dp1, dp2); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `a[] = { ``2``, ``5``, ``3``, ``1``, ``7``, ``3``, ``4` `}; ` `    ``int` `n = a.length; ` `    ``System.out.print(minimumCost(a, n)); ` `} ` `} `

## Python 3

 `# Python 3 program to find  ` `# the minimum cost required  ` `# to reach the n-th floor ` `# space-optimized solution ` ` `  `# function to find the minimum  ` `# cost to reach N-th floor ` `def` `minimumCost(cost, n): ` ` `  `    ``dp1 ``=` `0` `    ``dp2 ``=` `0` ` `  `    ``# traverse till N-th stair ` `    ``for` `i ``in` `range``(n): ` `        ``dp0 ``=` `cost[i] ``+` `min``(dp1, dp2) ` ` `  `        ``# update the last ` `        ``# two stairs value ` `        ``dp2 ``=` `dp1 ` `        ``dp1 ``=` `dp0 ` `    ``return` `min``(dp1, dp2) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``a ``=` `[ ``2``, ``5``, ``3``, ``1``, ``7``, ``3``, ``4` `] ` `    ``n ``=` `len``(a) ` `    ``print``(minimumCost(a, n)) ` `     `  `# This code is contributed ` `# by ChitraNayal `

## C#

 `// C# program to find the  ` `// minimum cost required to  ` `// reach the n-th floor  ` `// space-optimized solution ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// function to find  ` `// the minimum cost ` `// to reach N-th floor ` `static` `int` `minimumCost(``int``[] cost, ` `                       ``int` `n) ` `{ ` `    ``int` `dp1 = 0, dp2 = 0; ` ` `  `    ``// traverse till N-th stair ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``int` `dp0 = cost[i] +  ` `                  ``Math.Min(dp1, dp2); ` ` `  `        ``// update the last  ` `        ``// two stairs value ` `        ``dp2 = dp1; ` `        ``dp1 = dp0; ` `    ``} ` `    ``return` `Math.Min(dp1, dp2); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int``[] a = { 2, 5, 3, 1, 7, 3, 4 }; ` `    ``int` `n = a.Length; ` `    ``Console.Write(minimumCost(a, n)); ` `} ` `} ` ` `  `// This code is contributed ` `// by ChitraNayal `

## PHP

 ` `

Output:

```9
```

Time Complexity: O(N)
Auxiliary Space: O(1)

The following problem can be solved using top-down approach. In that case the recurrence will be dp[i] = cost[i] + min(dp[i+1], dp[i+2]).

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.