Related Articles
Count ways to reach the nth stair using step 1, 2 or 3
• Difficulty Level : Easy
• Last Updated : 05 May, 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++

 `// C++ Program to find n-th stair using step size``// 1 or 2 or 3.``#include ``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`

## C

 `// Program to find n-th stair using step size``// 1 or 2 or 3.``#include ` `// 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;``}`

## Java

 `// 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 */`

## Python

 `# 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.`

## C#

 `// 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 */`

## PHP

 ``

## Javascript

 ``

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++

 `// A C++ program to count number of ways``// to reach n't stair when``#include ``using` `namespace` `std;` `// A recursive function used by countWays``int` `countWays(``int` `n)``{``    ``int` `res[n + 1];``    ``res = 1;``    ``res = 1;``    ``res = 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`

## C

 `// A C program to count number of ways``// to reach n't stair when``#include ` `// A recursive function used by countWays``int` `countWays(``int` `n)``{``    ``int` `res[n + 1];``    ``res = 1;``    ``res = 1;``    ``res = 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;``}`

## Java

 `// 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 */`

## Python

 `# 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.`

## C#

 `// 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 = 1;``        ``res = 1;``        ``res = 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 */`

## PHP

 ``

## Javascript

 ``

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)```

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

## C++

 `#include ``#define k 3``using` `namespace` `std;` `// Multiply Two Matrix Function``vector> multiply(vector> A, vector> B) {``  ``// third matrix to store multiplication of Two matrix9*``  ``vector> 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> ``pow``(vector> t, ``int` `n) {``  ``// base Case``  ``if` `(n == 1) {``    ``return` `t;``  ``}``  ``// Recurrence Case``  ``if` `(n & 1) {``    ``return` `multiply(t, ``pow``(t, n - 1));``  ``} ``else` `{``    ``vector> 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;``  ``f1 = 2;``  ``f1 = 4;` `  ``// Constucting Transformation Matrix that will be``  ``/*[[0,1,0],[0,0,1],[3,2,1]]``   ``*/``  ``vector> 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[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;``}`
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)
ans = [2,4,7]
ans = 2 //[2,4,7] = First cell value of [2,4,7] i.e 2
for n=3 :
ans = (M X M X F1)  //M^(3-1) X F1 = M X M X F1
ans = (M X [2,4,7])
ans = [4,7,13]
ans = 4
for n = 4 :
ans = (M^(4-1) X F1)
ans = (M X M X M X F1) 
ans = (M X [4,7,13])
ans = [7,13,24]
ans = 7
for n = 5 :
ans = (M^4 X F1)
ans = (M X [7,13,24])
ans = [13,24,44]
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)```
My Personal Notes arrow_drop_up