# Counts Path in an Array

Given an array A consisting of positive integer, of size N. If the element in the array at index i is K then you can jump between index ranges (i + 1) to (i + K).
The task is to find the number of possible ways to reach the end with module 109 + 7.

The starting position is considered as index 0.

Examples:

Input: A = {5, 3, 1, 4, 3}
Output: 6

Input: A = {2, 3, 1, 1, 2}
Output: 4

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

Naive Approach: We can form a recursive structure to solve the problem.

Let F[i] denotes the number of paths starting at index i, at every index i if the element A[i] is K then the total number of ways the jump can be performed is:

```F(i) = F(i+1) + F(i+2) +...+ F(i+k), where i + k <= n,
where F(n) = 1
```

By using this recursive formula we can solve the problem:

## C++

 `// C++ implementation of ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `mod = 1e9 + 7; ` ` `  `// Find the number of ways ` `// to reach the end ` `int` `ways(``int` `i, ``int` `arr[], ``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(i == n - 1) ` `        ``return` `1; ` ` `  `    ``int` `sum = 0; ` ` `  `    ``// Recursive structure ` `    ``for` `(``int` `j = 1; ` `         ``j + i < n && j <= arr[i]; ` `         ``j++) { ` `        ``sum += (ways(i + j, ` `                     ``arr, n)) ` `               ``% mod; ` `        ``sum %= mod; ` `    ``} ` ` `  `    ``return` `sum % mod; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 5, 3, 1, 4, 3 }; ` ` `  `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``cout << ways(0, arr, n) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of ` `// the above approach ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` `static` `int` `mod = ``1000000000``; ` ` `  `// Find the number of ways ` `// to reach the end ` `static` `int` `ways(``int` `i,  ` `                ``int` `arr[], ``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(i == n - ``1``) ` `        ``return` `1``; ` ` `  `    ``int` `sum = ``0``; ` ` `  `    ``// Recursive structure ` `    ``for` `(``int` `j = ``1``; j + i < n &&  ` `                    ``j <= arr[i]; j++) ` `    ``{ ` `        ``sum += (ways(i + j, ` `                     ``arr, n)) % mod; ` `        ``sum %= mod; ` `    ``} ` `    ``return` `sum % mod; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args) ` `{ ` `    ``int` `arr[] = { ``5``, ``3``, ``1``, ``4``, ``3` `}; ` `     `  `    ``int` `n = arr.length; ` ` `  `    ``System.out.println (ways(``0``, arr, n)); ` `} ` `} ` ` `  `// This code is contributed by ajit `

## Python3

 `# Python3 implementation of ` `# the above approach ` ` `  `mod ``=` `1e9` `+` `7``; ` ` `  `# Find the number of ways ` `# to reach the end ` `def` `ways(i, arr, n): ` `     `  `    ``# Base case ` `    ``if` `(i ``=``=` `n ``-` `1``): ` `        ``return` `1``; ` ` `  `    ``sum` `=` `0``; ` ` `  `    ``# Recursive structure ` `    ``for` `j ``in` `range``(``1``, arr[i] ``+` `1``): ` `        ``if``(i ``+` `j < n): ` `            ``sum` `+``=` `(ways(i ``+` `j, arr, n)) ``%` `mod; ` `            ``sum` `%``=` `mod; ` ` `  `    ``return` `int``(``sum` `%` `mod); ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``5``, ``3``, ``1``, ``4``, ``3``]; ` ` `  `    ``n ``=` `len``(arr); ` ` `  `    ``print``(ways(``0``, arr, n)); ` ` `  `# This code is contributed by PrinciRaj1992 `

## C#

 `// C# implementation of ` `// the above approach ` `using` `System; ` `     `  `class` `GFG ` `{ ` `static` `int` `mod = 1000000000; ` ` `  `// Find the number of ways ` `// to reach the end ` `static` `int` `ways(``int` `i,  ` `                ``int` `[]arr, ``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(i == n - 1) ` `        ``return` `1; ` ` `  `    ``int` `sum = 0; ` ` `  `    ``// Recursive structure ` `    ``for` `(``int` `j = 1; j + i < n &&  ` `                    ``j <= arr[i]; j++) ` `    ``{ ` `        ``sum += (ways(i + j, ` `                     ``arr, n)) % mod; ` `        ``sum %= mod; ` `    ``} ` `    ``return` `sum % mod; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main (String[] args) ` `{ ` `    ``int` `[]arr = { 5, 3, 1, 4, 3 }; ` `     `  `    ``int` `n = arr.Length; ` ` `  `    ``Console.WriteLine(ways(0, arr, n)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```6
```

Efficient Approach: In the previous approach, there are some calculations that are being done more than once. It will be better to store these values in a dp array and dp[i] will store the number of paths starting at index i and ending at the end of the array.

Hence dp will be the solution to the problem.

Below is the implementation of the approach:

## C++

 `// C++ implementation ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `mod = 1e9 + 7; ` ` `  `// find the number of ways to reach the end ` `int` `ways(``int` `arr[], ``int` `n) ` `{ ` `    ``// dp to store value ` `    ``int` `dp[n + 1]; ` ` `  `    ``// base case ` `    ``dp[n - 1] = 1; ` ` `  `    ``// Bottom up dp structure ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) { ` `        ``dp[i] = 0; ` ` `  `        ``// F[i] is dependent of ` `        ``// F[i+1] to F[i+k] ` `        ``for` `(``int` `j = 1; ((j + i) < n ` `                         ``&& j <= arr[i]); ` `             ``j++) { ` `            ``dp[i] += dp[i + j]; ` `            ``dp[i] %= mod; ` `        ``} ` `    ``} ` ` `  `    ``// Return value of dp ` `    ``return` `dp % mod; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 5, 3, 1, 4, 3 }; ` ` `  `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``cout << ways(arr, n) % mod << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach ` `class` `GFG  ` `{ ` `    ``static` `final` `int` `mod = (``int``)(1e9 + ``7``);  ` `     `  `    ``// find the number of ways to reach the end  ` `    ``static` `int` `ways(``int` `arr[], ``int` `n)  ` `    ``{  ` `        ``// dp to store value  ` `        ``int` `dp[] = ``new` `int``[n + ``1``];  ` `     `  `        ``// base case  ` `        ``dp[n - ``1``] = ``1``;  ` `     `  `        ``// Bottom up dp structure  ` `        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--)  ` `        ``{  ` `            ``dp[i] = ``0``;  ` `     `  `            ``// F[i] is dependent of  ` `            ``// F[i+1] to F[i+k]  ` `            ``for` `(``int` `j = ``1``; ((j + i) < n &&  ` `                              ``j <= arr[i]); j++) ` `            ``{  ` `                ``dp[i] += dp[i + j];  ` `                ``dp[i] %= mod;  ` `            ``}  ` `        ``}  ` `     `  `        ``// Return value of dp  ` `        ``return` `dp[``0``] % mod;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args) ` `    ``{  ` `        ``int` `arr[] = { ``5``, ``3``, ``1``, ``4``, ``3` `};  ` `     `  `        ``int` `n = arr.length;  ` `     `  `        ``System.out.println(ways(arr, n) % mod);  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation of above approach ` `mod ``=` `10``*``*``9` `+` `7` ` `  `# find the number of ways to reach the end  ` `def` `ways(arr, n): ` `     `  `    ``# dp to store value  ` `    ``dp ``=` `[``0``] ``*` `(n ``+` `1``) ` `     `  `    ``# base case  ` `    ``dp[n ``-` `1``] ``=` `1` `     `  `    ``# Bottom up dp structure  ` `    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``): ` `        ``dp[i] ``=` `0` `         `  `        ``# F[i] is dependent of  ` `        ``# F[i + 1] to F[i + k]  ` `        ``j ``=` `1` `        ``while``((j ``+` `i) < n ``and` `j <``=` `arr[i]): ` `            ``dp[i] ``+``=` `dp[i ``+` `j]  ` `            ``dp[i] ``%``=` `mod  ` `            ``j ``+``=` `1` `     `  `    ``# Return value of dp  ` `    ``return` `dp[``0``] ``%` `mod  ` ` `  `# Driver code  ` `arr ``=` `[``5``, ``3``, ``1``, ``4``, ``3` `] ` `n ``=` `len``(arr)  ` `print``(ways(arr, n) ``%` `mod) ` ` `  `# This code is contributed by SHUBHAMSINGH10 `

## C#

 `// C# implementation of above approach ` `using` `System; ` `     `  `class` `GFG  ` `{ ` `    ``static` `readonly` `int` `mod = (``int``)(1e9 + 7);  ` `     `  `    ``// find the number of ways to reach the end  ` `    ``static` `int` `ways(``int` `[]arr, ``int` `n)  ` `    ``{  ` `        ``// dp to store value  ` `        ``int` `[]dp = ``new` `int``[n + 1];  ` `     `  `        ``// base case  ` `        ``dp[n - 1] = 1;  ` `     `  `        ``// Bottom up dp structure  ` `        ``for` `(``int` `i = n - 2; i >= 0; i--)  ` `        ``{  ` `            ``dp[i] = 0;  ` `     `  `            ``// F[i] is dependent of  ` `            ``// F[i+1] to F[i+k]  ` `            ``for` `(``int` `j = 1; ((j + i) < n &&  ` `                              ``j <= arr[i]); j++) ` `            ``{  ` `                ``dp[i] += dp[i + j];  ` `                ``dp[i] %= mod;  ` `            ``}  ` `        ``}  ` `     `  `        ``// Return value of dp  ` `        ``return` `dp % mod;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main (String[] args) ` `    ``{  ` `        ``int` `[]arr = { 5, 3, 1, 4, 3 };  ` `     `  `        ``int` `n = arr.Length;  ` `     `  `        ``Console.WriteLine(ways(arr, n) % mod);  ` `    ``}  ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```6
```

Time Complexity: O(K)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.