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

## 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 Second year Department of Information Technology Jadavpur University

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.