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

Difficulty Level : Easy
Last Updated : 19 Jan, 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 <bits/stdc++.h>
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;
}

Output

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 <bits/stdc++.h>
using namespace std;
 
// function to find the minimum cost
// to reach N-th floor
int minimumCostMemoized( int n,int cost[], vector<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] = min( minimumCostMemoized(n-1,cost,dp) + cost[n] ,
                        minimumCostMemoized(n-2, cost,dp)+ cost[n] );
}
 
int minimumCost(int cost[], int n){
    vector<int> dp(n, -1) ;
    int top = minimumCostMemoized( n-2,cost, dp) ;
    return dp[n-2] ;
  
}
 
// Driver Code
int main()
{
    int a[] = { 16, 19, 10, 12, 18 };
    int n = sizeof(a) / sizeof(a[0]);
    cout << minimumCost(a, n);
    return 0;
}

Output

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-1^th stair and n-2^th 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 <bits/stdc++.h>
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 dp[n - 2];
}
 
// 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

PHP

<?php
// PHP program to find the 
// minimum cost required 
// to reach the n-th floor
 
// function to find the minimum 
// cost to reach N-th floor
function minimumCost(&$cost, $n)
{
    // declare an array
 
    // 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 = 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
$a = array(16, 19, 10, 12, 18);
$n = sizeof($a);
echo(minimumCost($a, $n));
     
// This code is contributed
// by Shivi_Aggarwal
?>

Javascript

<script>
 
// Javascript program to find the
// minimum cost required to
// reach the n-th floor
 
     
    // function to find
// the minimum cost
// to reach N-th floor    
    function minimumCost(cost,n)
    {
        // declare an array
    let dp = new Array(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 (let 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
    let a=[16, 19, 10, 12, 18 ];
    let n = a.length;
    document.write(minimumCost(a, n));
     
 
// This code is contributed by rag2127
 
</script>

Output

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 <bits/stdc++.h>
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  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));
}
}

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

PHP

<?php
// PHP 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
function minimumCost(&$cost, $n)
{
    $dp1 = 0;
    $dp2 = 0;
 
    // traverse till N-th stair
    for ($i = 0; $i < $n; $i++) 
    {
        $dp0 = $cost[$i] +
               min($dp1, $dp2);
 
        // update the last 
        // two stairs value
        $dp2 = $dp1;
        $dp1 = $dp0;
    }
    return min($dp1, $dp2);
}
// Driver Code
$a = array(2, 5, 3, 1, 7, 3, 4);
$n = sizeof($a);
echo (minimumCost($a, $n));
 
// This code is contributed
// by Shivi_Aggarwal
?>

Javascript

<script>
// Javascript 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
    function minimumCost(cost,n)
    {
        let dp1 = 0, dp2 = 0;
  
    // traverse till N-th stair
    for (let i = 0; i < n; i++)
    {
        let dp0 = cost[i] +
                  Math.min(dp1, dp2);
  
        // update the last
        // two stairs value
        dp2 = dp1;
        dp1 = dp0;
    }
    return Math.min(dp1, dp2);
    }
     
    // Driver Code
    let a=[2, 5, 3, 1, 7, 3, 4 ];
    let n = a.length;
    document.write(minimumCost(a, n));
     
 
// This code is contributed by avanitrachhadiya2155
</script>

Output

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

Related Articles

Table of Contents

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

C++

C++

C++

Java

Python3

C#

PHP

Javascript

C++

Java

Python3

C#

PHP

Javascript

Start Your Coding Journey Now!