Related Articles

Related Articles

Count ways to reach the nth stair using step 1, 2 or 3
  • Difficulty Level : Easy
  • Last Updated : 25 Jan, 2021

A child is running up a staircase with n steps and can hop either 1 step, 2 steps, or 3 steps at a time. Implement a method to count how many possible ways the child can run up the stairs.
Examples: 

Input : 4
Output : 7
Explantion:
Below are the four ways
 1 step + 1 step + 1 step + 1 step
 1 step + 2 step + 1 step
 2 step + 1 step + 1 step 
 1 step + 1 step + 2 step
 2 step + 2 step
 3 step + 1 step
 1 step + 3 step

Input : 3
Output : 4
Explantion:
Below are the four ways
 1 step + 1 step + 1 step
 1 step + 2 step
 2 step + 1 step
 3 step

There are two methods to solve this problem:  

  1. Recursive Method
  2. Dynamic Programming

Method 1: Recursive. 
There are n stairs, and a person is allowed to jump next stair, skip one stair or skip two stairs. So there are n stairs. So if a person is standing at i-th stair, the person can move to i+1, i+2, i+3-th stair. A recursive function can be formed where at current index i the function is recursively called for i+1, i+2 and i+3 th stair. 
There is another way of forming the recursive function. To reach a stair i, a person has to jump either from i-1, i-2 or i-3 th stair or i is the starting stair.
Algorithm: 

  1. Create a recursive function (count(int n)) which takes only one parameter.
  2. Check the base cases. If the value of n is less than 0 then return 0, and if the value of n is equal to zero then return 1 as it is the starting stair.
  3. Call the function recursively with values n-1, n-2 and n-3 and sum up the values that are returned, i.e. sum = count(n-1) + count(n-2) + count(n-3)
  4. Return the value of the sum.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to find n-th stair using step size
// 1 or 2 or 3.
#include <iostream>
using namespace std;
 
class GFG {
 
    // Returns count of ways to reach n-th stair
    // using 1 or 2 or 3 steps.
public:
    int findStep(int n)
    {
        if (n == 1 || n == 0)
            return 1;
        else if (n == 2)
            return 2;
 
        else
            return findStep(n - 3) + findStep(n - 2)
                                   + findStep(n - 1);
    }
};
 
// Driver code
int main()
{
    GFG g;
    int n = 4;
    cout << g.findStep(n);
    return 0;
}
 
// This code is contributed by SoM15242

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find n-th stair using step size
// 1 or 2 or 3.
#include <stdio.h>
 
// Returns count of ways to reach n-th stair
// using 1 or 2 or 3 steps.
int findStep(int n)
{
    if (n == 1 || n == 0)
        return 1;
    else if (n == 2)
        return 2;
 
    else
        return findStep(n - 3) + findStep(n - 2) + findStep(n - 1);
}
 
// Driver code
int main()
{
    int n = 4;
    printf("%d\n", findStep(n));
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find n-th stair
// using step size 1 or 2 or 3.
import java.util.*;
import java.lang.*;
 
public class GfG {
 
    // Returns count of ways to reach
    // n-th stair using 1 or 2 or 3 steps.
    public static int findStep(int n)
    {
        if (n == 1 || n == 0)
            return 1;
        else if (n == 2)
            return 2;
 
        else
            return findStep(n - 3) + findStep(n - 2) + findStep(n - 1);
    }
 
    // Driver function
    public static void main(String argc[])
    {
        int n = 4;
        System.out.println(findStep(n));
    }
}
 
/* This code is contributed by Sagar Shukla */

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find n-th stair 
# using step size 1 or 2 or 3.
 
# Returns count of ways to reach n-th
# stair using 1 or 2 or 3 steps.
def findStep( n) :
    if (n == 1 or n == 0) :
        return 1
    elif (n == 2) :
        return 2
     
    else :
        return findStep(n - 3) + findStep(n - 2) + findStep(n - 1)
 
 
# Driver code
n = 4
print(findStep(n))
 
# This code is contributed by Nikita Tiwari.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find n-th stair
// using step size 1 or 2 or 3.
using System;
 
public class GfG {
 
    // Returns count of ways to reach
    // n-th stair using 1 or 2 or 3 steps.
    public static int findStep(int n)
    {
        if (n == 1 || n == 0)
            return 1;
        else if (n == 2)
            return 2;
 
        else
            return findStep(n - 3) + findStep(n - 2) + findStep(n - 1);
    }
 
    // Driver function
    public static void Main()
    {
        int n = 4;
        Console.WriteLine(findStep(n));
    }
}
 
/* This code is contributed by vt_m */

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP Program to find n-th stair
// using step size 1 or 2 or 3.
 
// Returns count of ways to
// reach n-th stair using 
// 1 or 2 or 3 steps.
function findStep($n)
{
    if ($n == 1 || $n == 0)
        return 1;
    else if ($n == 2)
        return 2;
     
    else
        return findStep($n - 3) +
               findStep($n - 2) +
                findStep($n - 1);
}
 
// Driver code
$n = 4;
echo findStep($n);
 
// This code is contributed by m_kit
?>

chevron_right


Output : 

7

Working:



Complexity Analysis: 

  • Time Complexity: O(3n). 
    The time complexity of the above solution is exponential, a close upper bound will be O(3n). From each state, 3 recursive function are called. So the upperbound for n states is O(3n).
  • Space Complexity:O(1). 
    As no extra space is required.

Note: The Time Complexity of the program can be optimized using Dynamic Programming.
Method 2: Dynamic Programming.
The idea is similar, but it can be observed that there are n states but the recursive function is called 3 ^ n times. That means that some states are called repeatedly. So the idea is to store the value of states. This can be done in two ways.  

  • Top-Down Approach: The first way is to keep the recursive structure intact and just store the value in a HashMap and whenever the function is called again return the value store without computing ().
  • Bottom-Up Approach: The second way is to take an extra space of size n and start computing values of states from 1, 2 .. to n, i.e. compute values of i, i+1, i+2 and then use them to calculate the value of i+3.

Algorithm:  

  1. Create an array of size n + 1 and initialize the first 3 variables with 1, 1, 2. The base cases.
  2. Run a loop from 3 to n.
  3. For each index i, computer value of ith position as dp[i] = dp[i-1] + dp[i-2] + dp[i-3].
  4. Print the value of dp[n], as the Count of the number of ways to reach n th step. 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// A C++ program to count number of ways
// to reach n't stair when
#include <iostream>
using namespace std;
 
// A recursive function used by countWays
int countWays(int n)
{
    int res[n + 1];
    res[0] = 1;
    res[1] = 1;
    res[2] = 2;
    for (int i = 3; i <= n; i++)
        res[i] = res[i - 1] + res[i - 2]
                + res[i - 3];
 
    return res[n];
}
 
// Driver program to test above functions
int main()
{
    int n = 4;
    cout << countWays(n);
    return 0;
}
//This code is contributed by shubhamsingh10

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// A C program to count number of ways
// to reach n't stair when
#include <stdio.h>
 
// A recursive function used by countWays
int countWays(int n)
{
    int res[n + 1];
    res[0] = 1;
    res[1] = 1;
    res[2] = 2;
    for (int i = 3; i <= n; i++)
        res[i] = res[i - 1] + res[i - 2]
                 + res[i - 3];
 
    return res[n];
}
 
// Driver program to test above functions
int main()
{
    int n = 4;
    printf("%d", countWays(n));
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find n-th stair
// using step size 1 or 2 or 3.
import java.util.*;
import java.lang.*;
 
public class GfG {
 
    // A recursive function used by countWays
    public static int countWays(int n)
    {
        int[] res = new int[n + 1];
        res[0] = 1;
        res[1] = 1;
        res[2] = 2;
 
        for (int i = 3; i <= n; i++)
            res[i] = res[i - 1] + res[i - 2]
                     + res[i - 3];
 
        return res[n];
    }
 
    // Driver function
    public static void main(String argc[])
    {
        int n = 4;
        System.out.println(countWays(n));
    }
}
 
/* This code is contributed by Sagar Shukla */

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find n-th stair 
# using step size 1 or 2 or 3.
 
# A recursive function used by countWays
def countWays(n) :
    res = [0] * (n + 2)
    res[0] = 1
    res[1] = 1
    res[2] = 2
     
    for i in range(3, n + 1) :
        res[i] = res[i - 1] + res[i - 2] + res[i - 3]
     
    return res[n]
 
# Driver code
n = 4
print(countWays(n))
 
 
# This code is contributed by Nikita Tiwari.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find n-th stair
// using step size 1 or 2 or 3.
using System;
 
public class GfG {
 
    // A recursive function used by countWays
    public static int countWays(int n)
    {
        int[] res = new int[n + 2];
        res[0] = 1;
        res[1] = 1;
        res[2] = 2;
 
        for (int i = 3; i <= n; i++)
            res[i] = res[i - 1] + res[i - 2]
                     + res[i - 3];
 
        return res[n];
    }
 
    // Driver function
    public static void Main()
    {
        int n = 4;
        Console.WriteLine(countWays(n));
    }
}
 
/* This code is contributed by vt_m */

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// A PHP program to count
// number of ways to reach
// n'th stair when
 
// A recursive function
// used by countWays
function countWays($n)
{
    $res[0] = 1;
    $res[1] = 1;
    $res[2] = 2;
    for ($i = 3; $i <= $n; $i++)
        $res[$i] = $res[$i - 1] +
                   $res[$i - 2] +
                   $res[$i - 3];
     
    return $res[$n];
}
 
// Driver Code
$n = 4;
echo countWays($n);
 
// This code is contributed by ajit
?>

chevron_right


Output : 
 

7
  • Working: 
1 -> 1 -> 1 -> 1
1 -> 1 -> 2
1 -> 2 -> 1
1 -> 3
2 -> 1 -> 1
2 -> 2
3 -> 1

So Total ways: 7
  • Complexity Analysis: 
    • Time Complexity: O(n). 
      Only one traversal of the array is needed. So Time Complexity is O(n).
    • Space Complexity: O(n). 
      To store the values in a DP, n extra space is needed.

Method 3: Matrix Exponentiation (O(logn) Approach)

Matrix Exponentiation is mathematical ways to solve DP problem in better time complexity . Matrix Exponentiation Technique has Transformation matrix of Size K X K and Functional Vector (K X 1) .By taking n-1th power of Transformation matrix and Multiplying It With functional vector Give Resultant Vector say it  Res  of Size K X 1. First Element of Res will be Answer for given n value. This Approach Will Take O(K^3logn) Time Complexity Which Is Complexity of Finding (n-1) power of Transformation Matrix.

Key Terms:

K = No of Terms in which F(n) depend ,from Recurrence Relation We can Say That F(n) depend On F(n-1) and F(n-2). => K =3

F1 =  Vector (1D array) that contain F(n) value of First K terms. Since K=3 =>F1 will have F(n) value of first 2 terms. F1=[1,2,4]

T = Transformation Matrix that is a 2D matrix of Size K X K and  Consist Of All 1 After Diagonal And Rest All Zero except last row. Last Row Will have coefficient Of all K terms in which F(n)  depends In Reverser Order. => T =[ [0 1 0] ,[0 0 1], [1 1 1] ].

Algorithms:

1)Take Input N
2)If N < K then Return Precalculated Answer  //Base Condition
3)construct F1 Vector and T (Transformation Matrix)
4)Take N-1th  power of T by using  Optimal Power(T,N) Methods and assign it in T
5)return (TXF)[1]

for Optimal Power(T,N) Methods Refer Following Article : https://www.geeksforgeeks.org/write-a-c-program-to-calculate-powxn/

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <bits/stdc++.h>
#define k 3
using namespace std;
 
// Multiply Two Matrix Function
vector<vector<int>> multiply(vector<vector<int>> A, vector<vector<int>> B) {
  // third matrix to store multiplication of Two matrix9*
  vector<vector<int>> C(k + 1, vector<int>(k + 1));
 
  for (int i = 1; i <= k; i++) {
    for (int j = 1; j <= k; j++) {
      for (int x = 1; x <= k; x++) {
        C[i][j] = (C[i][j] + (A[i][x] * B[x][j]));
      }
    }
  }
 
  return C;
}
// Optimal Way For finding pow(t,n)
// If n Is Odd then It Will be t*pow(t,n-1)
// else return pow(t,n/2)*pow(t,n/2)
vector<vector<int>> pow(vector<vector<int>> t, int n) {
  // base Case
  if (n == 1) {
    return t;
  }
  // Recurrence Case
  if (n & 1) {
    return multiply(t, pow(t, n - 1));
  } else {
    vector<vector<int>> X = pow(t, n / 2);
    return multiply(X, X);
  }
}
 
int compute(int n) {
  // base Case
  if (n == 0) return 1;
  if (n == 1) return 1;
  if (n == 2) return 2;
 
  // Function Vector(indexing 1 )
  // that is [1,2]
  int f1[k + 1] = {};
  f1[1] = 1;
  f1[2] = 2;
  f1[3] = 4;
 
  // Constucting Transformation Matrix that will be
  /*[[0,1,0],[0,0,1],[3,2,1]]
   */
  vector<vector<int>> t(k + 1, vector<int>(k + 1));
  for (int i = 1; i <= k; i++) {
    for (int j = 1; j <= k; j++) {
      if (i < k) {
        // Store 1 in cell that is next to diagonal of Matrix else Store 0 in
        // cell
        if (j == i + 1) {
          t[i][j] = 1;
        } else {
          t[i][j] = 0;
        }
        continue;
      }
      // Last Row - store the Coefficients in reverse order
      t[i][j] = 1;
    }
  }
 
  // Computing T^(n-1) and Setting Tranformation matrix T to T^(n-1)
  t = pow(t, n - 1);
  int sum = 0;
  // Computing first cell (row=1,col=1) For Resultant Matrix TXF
  for (int i = 1; i <= k; i++) {
    sum += t[1][i] * f1[i];
  }
  return sum;
}
int main() {
  int n = 4;
  cout << compute(n) << endl;
  n = 5;
  cout << compute(n) << endl;
  n = 10;
  cout << compute(n) << endl;
 
  return 0;
}

chevron_right


Output

7
13
274
Explanation:
We Know For This Question 
Transformation Matrix M= [[0,1,0],[0,0,1],[1,1,1]]
Functional Vector F1 = [1,2,4]
for n=2 :
    ans = (M X F1)[1]  
    ans = [2,4,7][1]  
    ans = 2 //[2,4,7][1] = First cell value of [2,4,7] i.e 2
for n=3 :
    ans = (M X M X F1)[1]  //M^(3-1) X F1 = M X M X F1
    ans = (M X [2,4,7])[1] 
    ans = [4,7,13][1]
    ans = 4
for n = 4 :
    ans = (M^(4-1) X F1)[1]
    ans = (M X M X M X F1) [1] 
    ans = (M X [4,7,13])[1] 
    ans = [7,13,24][1]
    ans = 7
for n = 5 :
    ans = (M^4 X F1)[1]
    ans = (M X [7,13,24])[1]
    ans = [13,24,44][1]
    ans = 13

Time Complexity:

O(K^3log(n)) //For Computing pow(t,n-1)
For this question K is 3
So Overall Time Complexity is O(27log(n))=O(logn)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :