Open In App

# Count ways to reach Nth Stairs by taking 1 and 2 steps with exactly one 3 step

Given the number N which denotes the number of stairs, the task is to reach the Nth stair by taking 1, 2 steps any number of times and taking a step of 3 exactly once.

Examples:

Input: N = 4
Output:
Explanation:
Since a step of 3 has to be taken compulsorily and only once,
There are only two possible ways: (1, 3) or (3, 1)

Input: N = 5
Output:
Explanation:
Since a step of 3 has to be taken compulsorily and only once,
There are only 5 possible ways:
(1, 1, 3), (1, 3, 1), (3, 1, 1), (2, 3), (3, 2)

Approach: This problem can be solved using Dynamic Programming. To Reach Nth stair the person should be on (N – 1)th, (N – 2)th or (N – 3)th. So, To reach Nth stair from the base Reach (N – 1)th stair which includes exact only one step of 3, Reach (N – 2)th step with the steps which includes exactly one step of 3 and Reach the (N – 3)th step without taking any step of 3.
So, The Recurrence Relation for this problem will be –

includes_3[i] = includes_3[i-1] + includes_3[i-2] + not_includes[i-3]

whereas, the Recurrence relation when the 3 number of steps at a time is not allowed is

not_includes[i] = not_includes[i – 1] + not_includes[i – 2]

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the number``// the number of ways to reach Nth stair``// by taking 1, 2 step at a time and``// 3 Steps at a time exactly once.` `#include ``using` `namespace` `std;` `// Function to find the number``// the number of ways to reach Nth stair``int` `number_of_ways(``int` `n)``{``    ``// Array including number``    ``// of ways that includes 3``    ``int` `includes_3[n + 1] = {};` `    ``// Array including number of``    ``// ways that doesn't includes 3``    ``int` `not_includes_3[n + 1] = {};` `    ``// Initially to reach 3 stairs by``    ``// taking 3 steps can be``    ``// reached by 1 way``    ``includes_3 = 1;` `    ``not_includes_3 = 1;``    ``not_includes_3 = 2;``    ``not_includes_3 = 3;` `    ``// Loop to find the number``    ``// the number of ways to reach Nth stair``    ``for` `(``int` `i = 4; i <= n; i++) {``        ``includes_3[i]``            ``= includes_3[i - 1] + includes_3[i - 2] + not_includes_3[i - 3];``        ``not_includes_3[i]``            ``= not_includes_3[i - 1] + not_includes_3[i - 2];``    ``}``    ``return` `includes_3[n];``}` `// Driver Code``int` `main()``{``    ``int` `n = 7;` `    ``cout << number_of_ways(n);` `    ``return` `0;``}`

## Java

 `// Java implementation to find the number``// the number of ways to reach Nth stair``// by taking 1, 2 step at a time and``// 3 Steps at a time exactly once.``class` `GFG``{` `// Function to find the number``// the number of ways to reach Nth stair``static` `int` `number_of_ways(``int` `n)``{``    ``// Array including number``    ``// of ways that includes 3``    ``int` `[]includes_3 = ``new` `int``[n + ``1``];``    ` `    ``// Array including number of``    ``// ways that doesn't includes 3``    ``int` `[]not_includes_3 = ``new` `int``[n + ``1``];` `    ``// Initially to reach 3 stairs by``    ``// taking 3 steps can be``    ``// reached by 1 way``    ``includes_3[``3``] = ``1``;` `    ``not_includes_3[``1``] = ``1``;``    ``not_includes_3[``2``] = ``2``;``    ``not_includes_3[``3``] = ``3``;` `    ``// Loop to find the number``    ``// the number of ways to reach Nth stair``    ``for` `(``int` `i = ``4``; i <= n; i++)``    ``{``        ``includes_3[i]``            ``= includes_3[i - ``1``] + includes_3[i - ``2``] +``               ``not_includes_3[i - ``3``];``        ``not_includes_3[i]``            ``= not_includes_3[i - ``1``] + not_includes_3[i - ``2``];``    ``}``    ``return` `includes_3[n];``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``7``;` `    ``System.out.print(number_of_ways(n));``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation to find the number``# the number of ways to reach Nth stair``# by taking 1, 2 step at a time and``# 3 Steps at a time exactly once.` `# Function to find the number``# the number of ways to reach Nth stair``def` `number_of_ways(n):``    ` `    ``# Array including number``    ``# of ways that includes 3``    ``includes_3 ``=` `[``0``]``*``(n ``+` `1``)` `    ``# Array including number of``    ``# ways that doesn't includes 3``    ``not_includes_3 ``=` `[``0``] ``*` `(n ``+` `1``)` `    ``# Initially to reach 3 stairs by``    ``# taking 3 steps can be``    ``# reached by 1 way``    ``includes_3[``3``] ``=` `1` `    ``not_includes_3[``1``] ``=` `1``    ``not_includes_3[``2``] ``=` `2``    ``not_includes_3[``3``] ``=` `3` `    ``# Loop to find the number``    ``# the number of ways to reach Nth stair``    ``for` `i ``in` `range``(``4``, n ``+` `1``):``        ``includes_3[i] ``=` `includes_3[i ``-` `1``] ``+` `\``                        ``includes_3[i ``-` `2``] ``+` `\``                        ``not_includes_3[i ``-` `3``]``        ``not_includes_3[i] ``=` `not_includes_3[i ``-` `1``] ``+` `\``                           ``not_includes_3[i ``-` `2``]``    ``return` `includes_3[n]` `# Driver Code``n ``=` `7` `print``(number_of_ways(n))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation to find the number``// the number of ways to reach Nth stair``// by taking 1, 2 step at a time and``// 3 Steps at a time exactly once.``using` `System;` `class` `GFG``{` `// Function to find the number``// the number of ways to reach Nth stair``static` `int` `number_of_ways(``int` `n)``{``    ``// Array including number``    ``// of ways that includes 3``    ``int` `[]includes_3 = ``new` `int``[n + 1];``    ` `    ``// Array including number of``    ``// ways that doesn't includes 3``    ``int` `[]not_includes_3 = ``new` `int``[n + 1];` `    ``// Initially to reach 3 stairs by``    ``// taking 3 steps can be``    ``// reached by 1 way``    ``includes_3 = 1;` `    ``not_includes_3 = 1;``    ``not_includes_3 = 2;``    ``not_includes_3 = 3;` `    ``// Loop to find the number``    ``// the number of ways to reach Nth stair``    ``for` `(``int` `i = 4; i <= n; i++)``    ``{``        ``includes_3[i]``            ``= includes_3[i - 1] + includes_3[i - 2] +``            ``not_includes_3[i - 3];``        ``not_includes_3[i]``            ``= not_includes_3[i - 1] + not_includes_3[i - 2];``    ``}``    ``return` `includes_3[n];``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 7;` `    ``Console.Write(number_of_ways(n));``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

```20

```

Time complexity: O(n) where N is given the number of stairs
Auxiliary space: O(n)

Efficient approach: Space Optimization O(1)

The above approach includes_3 and not_includes_3, each of size n + 1. However, we can observe that at any given point in the loop, we only need the values of the arrays for the current iteration and the previous two iterations. So to optimize the space complexity, we can replace the arrays with three variables that store the necessary values.

Implementation Steps:

• Initialize variables: in1, in2, in3, incurr, not_in1, not_in2, not_in3, not_incurr.
• Set the initial value of in3 to 1.
• Iterate from i = 4 to n.
• Calculate the current value of incurr by summing the previous values of in3, in2, and not_in1.
• Calculate the current value of not_incurr by summing the previous values of not_in3 and not_in2.
• Update variables for the next iteration by shifting the values.
• Return the final value of incurr.

Implementation:

## C++

 `#include ``using` `namespace` `std;` `// Function to find the number``// the number of ways to reach Nth stair``int` `number_of_ways(``int` `n)``{``    ``int` `in1, in2 = 0, in3, incurr;``    ``int` `not_in1 = 1, not_in2 = 2, not_in3 = 3, not_incurr;``    ` `    ``in3 = 1;  ``// Set the initial value for in3``    ` `    ``for` `(``int` `i = 4; i <= n; i++) {``        ``// Calculate the current value for incurr by summing the previous values``        ``incurr = in3 + in2 + not_in1;``        ` `        ``// Calculate the current value for not_incurr by summing the previous values``        ``not_incurr = not_in3 + not_in2;``        ` `        ``// Update the variables for the next iteration``        ``in1 = in2;``        ``in2 = in3;``        ``in3 = incurr;``        ` `        ``not_in1 = not_in2;``        ``not_in2 = not_in3;``        ``not_in3 = not_incurr;``    ``}` `    ``return` `incurr;  ``// Return the final result``}` `// Driver Code``int` `main()``{``    ``int` `n = 7;``    ``cout << number_of_ways(n);  ``// Print the result` `    ``return` `0;``}`

## Python3

 `# Function to find the number``# of ways to reach Nth stair``def` `number_of_ways(n):``    ``in1, in2 ``=` `0``, ``0``    ``in3, incurr ``=` `1``, ``0``    ``not_in1, not_in2, not_in3, not_incurr ``=` `1``, ``2``, ``3``, ``0``    ` `    ``in3 ``=` `1`  `# Set the initial value for in3``    ` `    ``for` `i ``in` `range``(``4``, n ``+` `1``):``        ``# Calculate the current value for incurr by summing the previous values``        ``incurr ``=` `in3 ``+` `in2 ``+` `not_in1``        ` `        ``# Calculate the current value for not_incurr by summing the previous values``        ``not_incurr ``=` `not_in3 ``+` `not_in2``        ` `        ``# Update the variables for the next iteration``        ``in1, in2, in3 ``=` `in2, in3, incurr``        ` `        ``not_in1, not_in2, not_in3 ``=` `not_in2, not_in3, not_incurr``    ` `    ``return` `incurr  ``# Return the final result` `# Driver Code``def` `main():``    ``n ``=` `7``    ``print``(number_of_ways(n))  ``# Print the result` `main()`

## C#

 `using` `System;` `class` `Program {``    ``// Function to find the number of ways to reach the Nth``    ``// stair``    ``static` `int` `NumberOfWays(``int` `n)``    ``{``        ``int` `in2 = 0, in3 = 1, incurr;``        ``int` `not_in1 = 1, not_in2 = 2, not_in3 = 3,``            ``not_incurr;` `        ``incurr = 0; ``// Initialize incurr``        ``not_incurr = 0; ``// Initialize not_incurr` `        ``for` `(``int` `i = 4; i <= n; i++) {``            ``// Calculate the current value for incurr by``            ``// summing the previous values``            ``incurr = in3 + in2 + not_in1;` `            ``// Calculate the current value for not_incurr by``            ``// summing the previous values``            ``not_incurr = not_in3 + not_in2;` `            ``// Update the variables for the next iteration``            ``in2 = in3;``            ``in3 = incurr;` `            ``not_in1 = not_in2;``            ``not_in2 = not_in3;``            ``not_in3 = not_incurr;``        ``}` `        ``return` `incurr; ``// Return the final result``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``int` `n = 7;``        ``Console.WriteLine(``            ``NumberOfWays(n)); ``// Print the result``    ``}``}`

## Javascript

 `// Function to find the number``// the number of way to reach Nth stair``function` `numberOfWays(n) {``    ``let in1, in2 = 0, in3, inCurr;``    ``let not_in1 = 1, not_in2 = 2, not_in3 = 3, not_inCurr;``    ` `    ``in3 = 1; ``// Set the initial value for in3``    ` `    ``for` `(let i = 4; i <= n; i++) {``        ``// Calculate the current value for inCurr by summing the previous values``        ``inCurr = in3 + in2 + not_in1;``        ``// Calculate the current value for not_inCurr by summing the previous values``        ``not_inCurr = not_in3 + not_in2;       ``        ``// Update the variables for the next iteration``        ``in1 = in2;``        ``in2 = in3;``        ``in3 = inCurr;       ``        ``not_in1 = not_in2;``        ``not_in2 = not_in3;``        ``not_in3 = not_inCurr;``    ``}``    ``return` `inCurr; ``// Return the final result``}``// Driver Code``function` `main() {``    ``const n = 7;``    ``console.log(numberOfWays(n)); ``// Print the result``}``main();`

Output:

`20`

Time complexity: O(n) where N is given the number of stairs
Auxiliary space: O(1)

Similar Article: Count ways to reach Nth Stair using 1, 2 or 3 steps at a time