Related Articles
Count ways to reach the Nth stair using any step from the given array
• Last Updated : 07 Jan, 2020

Given N stairs and a person standing at the bottom wants to reach the top. He could climb any number of steps from the given array arr[] of positive integers. The task is to find the count of all possible ways to reach the top.

Examples:

Input: arr[] = {1, 3, 5}, N = 5
Output: 5
(0 -> 1 -> 2 -> 3 -> 4 -> 5), (0 -> 1 -> 2 -> 5),
(0 -> 1 -> 4 -> 5), (0 -> 3 -> 4 -> 5)
and (0 -> 5) are the only possible ways.

Input: arr[] = {1, 2, 3}, N = 10
Output: 274

Naive approach: Using recursion, find all the possible ways and count them.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Recursive function to return the``// total ways to reach the n'th stair``int` `countWays(``int` `n, ``int` `arr[], ``int` `len)``{``    ``// Base case``    ``if` `(n == 0)``        ``return` `1;`` ` `    ``// To store the number of ways``    ``int` `no_ways = 0;`` ` `    ``// Iterate each element of the given array``    ``for` `(``int` `i = 0; i < len; i++) {`` ` `        ``// Here consider only the values of``        ``// "n - arr[i]" >= 0 because negative values``        ``// of n in the stair function are``        ``// not defined``        ``if` `(n - arr[i] >= 0) {``            ``no_ways += countWays(n - arr[i], arr, len);``        ``}``    ``}``    ``return` `no_ways;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 3, 5 };``    ``int` `len = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `n = 5;`` ` `    ``cout << countWays(n, arr, len);`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG {`` ` `    ``// Recursive function to return the``    ``// total ways to reach the n'th stair``    ``static` `int` `countWays(``int` `n, ``int` `arr[], ``int` `len)``    ``{``        ``// Base case``        ``if` `(n == ``0``)``            ``return` `1``;`` ` `        ``// To store the number of ways``        ``int` `no_ways = ``0``;`` ` `        ``// Iterate each element of the given array``        ``for` `(``int` `i = ``0``; i < len; i++) {`` ` `            ``// Here consider only the values of``            ``// "n - arr[i]" >= 0 because negative values``            ``// of n in the stair function are``            ``// not defined``            ``if` `(n - arr[i] >= ``0``) {``                ``no_ways += countWays(n - arr[i], arr, len);``            ``}``        ``}``        ``return` `no_ways;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``1``, ``3``, ``5` `};``        ``int` `len = arr.length;``        ``;``        ``int` `n = ``5``;`` ` `        ``System.out.println(countWays(n, arr, len));``    ``}``}`

## Python

 `# Python3 implementation of the approach`` ` `# Recursive function to return the``# total ways to reach the n'th stair``def` `countWays(n, arr):``     ` `    ``# Base case``    ``if` `(n ``=``=` `0``):``        ``return` `1`` ` `    ``# To store the number of ways``    ``no_ways ``=` `0``     ` `    ``# Iterate each element of the given array``    ``for` `i ``in` `arr:``         ` `        ``# Here consider only the values of``        ``# "n - arr[i]" >= 0 because negative values``        ``# of n in the stair function are``        ``# not defined``        ``if` `(n ``-` `i >``=` `0``):``            ``no_ways ``=` `no_ways ``+` `countWays(n ``-` `i, arr)``    ``return` `no_ways`` ` `# Driver code``arr ``=` `[``1``, ``3``, ``5``]``n ``=` `5``print``(countWays(n, arr))`

## C#

 `// C# implementation of the approach``using` `System;`` ` `class` `GFG``{`` ` `// Recursive function to return the``// total ways to reach the n'th stair``static` `int` `countWays(``int` `n, ``int` `[]arr, ``                            ``int` `len)``{``    ``// Base case``    ``if` `(n == 0)``        ``return` `1;`` ` `    ``// To store the number of ways``    ``int` `no_ways = 0;`` ` `    ``// Iterate each element ``    ``// of the given array``    ``for` `(``int` `i = 0; i < len; i++) ``    ``{`` ` `        ``// Here consider only the values of``        ``// "n - arr[i]" >= 0 because negative values``        ``// of n in the stair function are``        ``// not defined``        ``if` `(n - arr[i] >= 0) ``        ``{``            ``no_ways += countWays(n - arr[i], arr, len);``        ``}``    ``}``    ``return` `no_ways;``}`` ` `// Driver code``public` `static` `void` `Main()``{``    ``int` `[]arr = { 1, 3, 5 };``    ``int` `len = arr.Length;``    ``int` `n = 5;`` ` `    ``Console.Write(countWays(n, arr, len));``}``}`` ` `// This code is contributed by Mohit Kumar`
Output:
```5
```

Efficient approach: In this method instead of using a recursive approach, go for a dynamic programming based approach.

• Create an array count[] of size equal to the total number of steps + 1 with all elements initialized to 0 and initialize the first element i.e. count to 1.
• Initialize a variable no_ways = 0 inside the for loop and everytime starting from 0 for the new ways of climbing the stairs.
• Add count[i – x[j]] to no_ways only if i – x[j] ≥ 0.
• Finally, return count[N] which is essentially the number of ways to climb the Nth stair.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Function to return the total number``// of ways to reach the n'th stair``int` `countWays(``int` `n, ``int` `arr[], ``int` `len)``{`` ` `    ``// To store the number of ways``    ``// to reach the ith stair``    ``int` `count[n + 1] = { 0 };``    ``count = 1;`` ` `    ``// Base case``    ``if` `(n == 0)``        ``return` `1;`` ` `    ``// For every stair``    ``for` `(``int` `i = 1; i <= n; i++) {`` ` `        ``// To store the count of ways``        ``// till the current stair``        ``int` `no_ways = 0;`` ` `        ``// Every step from the array``        ``for` `(``int` `j = 0; j < len; j++) {`` ` `            ``// Here consider only``            ``// the values of "i - arr[j]" >= 0``            ``// because negative values``            ``// indicates reverse climbing``            ``// of steps``            ``if` `(i - arr[j] >= 0) {``                ``no_ways += count[i - arr[j]];``            ``}``            ``count[i] = no_ways;``        ``}``    ``}`` ` `    ``return` `count[n];``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 3, 5 };``    ``int` `len = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `n = 5;`` ` `    ``cout << countWays(n, arr, len);`` ` `    ``return` `0;``}`

## Java

 `// java implementation of the approach``class` `GFG {`` ` `    ``// Function to return the total number``    ``// of ways to reach the n'th stair``    ``static` `int` `countWays(``int` `n, ``int` `arr[], ``int` `len)``    ``{`` ` `        ``// To store the number of ways``        ``// to reach the ith stair``        ``int` `count[] = ``new` `int``[n + ``1``];``        ``count[``0``] = ``1``;`` ` `        ``// Base case``        ``if` `(n == ``0``)``            ``return` `1``;`` ` `        ``// For every stair``        ``for` `(``int` `i = ``1``; i <= n; i++) {`` ` `            ``// To store the count of ways``            ``// till the current stair``            ``int` `no_ways = ``0``;`` ` `            ``// Every step from the array``            ``for` `(``int` `j = ``0``; j < len; j++) {`` ` `                ``// Here consider only``                ``// the values of "i - arr[j]" >= 0``                ``// because negative values``                ``// indicates reverse climbing``                ``// of steps``                ``if` `(i - arr[j] >= ``0``) {``                    ``no_ways += count[i - arr[j]];``                ``}``                ``count[i] = no_ways;``            ``}``        ``}`` ` `        ``return` `count[n];``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``1``, ``3``, ``5` `};``        ``int` `len = arr.length;``        ``int` `n = ``5``;`` ` `        ``System.out.print(countWays(n, arr, len));``    ``}``}`

## Python3

 `# Python3 implementation of the approach`` ` `# Function to return the total number ``# of ways to reach the n'th stair``def` `countWays(n, arr):``     ` `    ``# To store the number of ways ``    ``# to reach the ith stair``    ``count ``=` `[``0``] ``*` `(n ``+` `1``)``    ``count[``0``] ``=` `1``     ` `    ``# Base case``    ``if` `(n ``=``=` `0``):``        ``return` `1``     ` `    ``# For every stair``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``         ` `        ``# To store the count of ways ``        ``# till the current stair``        ``no_ways ``=` `0``         ` `        ``# Every step from the array``        ``for` `j ``in` `arr:``             ` `            ``# Here consider only``            ``# the values of "i - arr[j]" >= 0``            ``# because negative values``            ``# indicates reverse climbing``            ``# of steps``            ``if` `(i ``-` `j >``=` `0``):``                ``no_ways ``+``=` `count[i ``-` `j]``            ``count[i] ``=` `no_ways`` ` `    ``return` `count[n]`` ` `# Driver code``arr ``=` `[``1``, ``3``, ``5``]``n ``=` `5``print``(countWays(n, arr))`

## C#

 `// C# implementation of the approach``using` `System;`` ` `class` `GFG ``{`` ` `    ``// Function to return the total number``    ``// of ways to reach the n'th stair``    ``static` `int` `countWays(``int` `n, ``int` `[]arr, ``int` `len)``    ``{`` ` `        ``// To store the number of ways``        ``// to reach the ith stair``        ``int` `[]count = ``new` `int``[n + 1];``        ``count = 1;`` ` `        ``// Base case``        ``if` `(n == 0)``            ``return` `1;`` ` `        ``// For every stair``        ``for` `(``int` `i = 1; i <= n; i++)``        ``{`` ` `            ``// To store the count of ways``            ``// till the current stair``            ``int` `no_ways = 0;`` ` `            ``// Every step from the array``            ``for` `(``int` `j = 0; j < len; j++)``            ``{`` ` `                ``// Here consider only``                ``// the values of "i - arr[j]" >= 0``                ``// because negative values``                ``// indicates reverse climbing``                ``// of steps``                ``if` `(i - arr[j] >= 0)``                ``{``                    ``no_ways += count[i - arr[j]];``                ``}``                ``count[i] = no_ways;``            ``}``        ``}``        ``return` `count[n];``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr = { 1, 3, 5 };``        ``int` `len = arr.Length;``        ``int` `n = 5;`` ` `        ``Console.WriteLine(countWays(n, arr, len));``    ``}``}`` ` `// This code is contributed by AnkitRai01`
Output:
```5
```

Time Complexity: O(N * len) where N is the number of stairs and len is the length of the array.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up