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

• Difficulty Level : Easy
• Last Updated : 08 Aug, 2022

Given N non-negative integers which signifies the cost of the moving from each stair. Paying the cost at i-th step, you can either climb one or two steps. Given that one can start from the 0-the step or 1-the step, the task is to find the minimum cost to reach the top of the floor(N+1) by climbing N stairs.

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

Approach 1: Using recursion

Basically an extension of this problem

The thing is we don’t need to go till the last element (since there are all positive numbers then we can avoid climbing to the last element so that we can reduce the cost).

## 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 n , int cost[]){     if(n == 0) return cost[0] ;     if(n == 1) return cost[1] ;          int top = min( minimumCost(n-1,cost) + cost[n] ,                         minimumCost(n-2, cost)+ cost[n] );    }   // Driver Code int main() {     int a[] = { 16, 19, 10, 12, 18 };     int n = sizeof(a) / sizeof(a[0]);     cout << minimumCost(n-2, a);     return 0; }

## Java

 /* Java code for finding minimum cost */ import java.io.*;   class GFG {     // function to find minimum cost   public static int minimumCost(int n, int cost[]){     if(n == 0) return cost[0] ;     if(n == 1) return cost[1] ;       int top = Math.min( minimumCost(n-1,cost) + cost[n] ,                        minimumCost(n-2, cost)+ cost[n] );     return top;   }   public static void main (String[] args) {     int a[] = { 16, 19, 10, 12, 18 };     int n = a.length;     System.out.println(minimumCost(n-2,a));   } }   //  This code is contributed by rchandra

## Python3

 # Python3 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):     if n == 0:         return cost[0]     if n == 1:         return cost[1]     return min(minimumCost(cost, n-1) + cost[n], minimumCost(cost, n-2) + cost[n])     # Driver Code if __name__ == "__main__":     a = [16, 19, 10, 12, 18]     n = len(a)     print(minimumCost(a, n-2))

Output

31

Time Complexity: O(N)

Auxiliary Space: O(1)

Approach 2: Memoization

We can store the recursion result in the array dp[]

## 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 minimumCostMemoized(int n, vector &cost, vector &dp) {     if (n == 0)         return cost[0];     if (n == 1)         return cost[1];     if (dp[n] != -1)         return dp[n];     dp[n] = min(minimumCostMemoized(n - 1, cost, dp) + cost[n],                 minimumCostMemoized(n - 2, cost, dp) + cost[n]);     return dp[n]; }   int minCostClimbingStairs(vector &cost) {     int n = cost.size();     vector dp(n + 1, -1);     int ans = min(minimumCostMemoized(n - 2, cost, dp), minimumCostMemoized(n - 1, cost, dp));     return ans; }   // Driver Code int main() {     vector a{ 16, 19, 10, 12, 18 };     cout << minCostClimbingStairs(a);     return 0; }

## Java

 /*package whatever //do not write package name here */   import java.io.*; import java.util.Arrays;   class GFG {   // function to find the minimum cost   // to reach N-th floor   static int minimumCostMemoized( int n,int cost[], int dp[])   {     // base case     if(n == 0) return cost[0] ;     if(n == 1) return cost[1] ;       if(dp[n] != -1) return dp[n];       return dp[n] = Math.min( minimumCostMemoized(n-1,cost,dp) + cost[n] ,                             minimumCostMemoized(n-2, cost,dp)+ cost[n] );   }     static int minimumCost(int cost[], int n){     int dp[] = new int[n];     Arrays.fill(dp,-1);     int top = minimumCostMemoized( n-2,cost, dp) ;     return dp[n-2] ;   }     public static void main (String[] args) {     int a[] = { 16, 19, 10, 12, 18 };     int n = a.length;     System.out.println(minimumCost(a,n));   } }   // This code is contributed by rchandra.

## Python3

 # Python3 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 minimumCostMemoized(n, cost, dp):     if n == 0:         return cost[0]     if n == 1:         return cost[1]     if dp[n] != -1:         return dp[n]     dp[n] = min(minimumCostMemoized(n - 1, cost, dp) + cost[n], minimumCostMemoized(n - 2, cost, dp) + cost[n])     return dp[n]       def minCostClimbingStairs(cost):     n = len(a)     dp = [-1]*n     ans = min(minimumCostMemoized(n - 2, cost, dp), minimumCostMemoized(n - 1, cost, dp))     return ans   # Driver Code if __name__ == "__main__":     a = [16, 19, 10, 12, 18 ]     print(minCostClimbingStairs(a))

Output

31

Time Complexity: O(N)

Auxiliary Space: O(N)

Approach 3: 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] are needed to compute the cost of traveling from i-th step, a bottom-up approach can be used to solve the problem. The answer will be the minimum cost of reaching n-1th stair and n-2th stair. Compute the dp[] array in a 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)); } }

## Python3

 # Python3 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



## Javascript



Output

31

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

Space-optimized Approach 4: Instead of using dp[] array for memoizing the cost, use two-variable dp1 and dp2. Since the cost of reaching the last two stairs is 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;     }   //dp2 gives the cost if started climbing from index 1 and dp1 from index 0     return  min(dp2,dp1); } // 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)); } }

## Python3

 # Python3 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



## Javascript



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]).

My Personal Notes arrow_drop_up
Recommended Articles
Page :