Related Articles
Count ways to reach Nth Stairs by taking 1 and 2 steps with exactly one 3 step
• Difficulty Level : Medium
• Last Updated : 14 Jul, 2020

Given a 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: 2
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: 5
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)

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 inclues 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] = {}; ` ` `  `    ``// Intially 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``]; ` ` `  `    ``// Intially 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``) ` ` `  `    ``# Intially 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]; ` ` `  `    ``// Intially 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 `

Output:

```20
```

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

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 :