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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of
// the above approach
#include <bits/stdc++.h>
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[0]);
  
    cout << ways(0, arr, n) << endl;
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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[0] will be the solution to the problem.

Below is the implementation of the approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation
#include <bits/stdc++.h>
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[0]
    return dp[0] % mod;
}
  
// Driver code
int main()
{
    int arr[] = { 5, 3, 1, 4, 3 };
  
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << ways(arr, n) % mod << endl;
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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[0] 
        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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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[0] 
        return dp[0] % 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

chevron_right


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.