Minimum number of Fibonacci jumps to reach end

Given an array of 0s and 1s, If any particular index i has value 1 then it is a safe index and if the value is 0 then it is an unsafe index. A man is standing at index -1(source) can only land on a safe index and he has to reach the Nth index (last position). At each jump, the man can only travel a distance equal to any Fibonacci Number. You have to minimize the number of steps, provided man can jump only in forward direction.

Note: First few Fibonacci numbers are – 0, 1, 1, 2, 3, 5, 8, 13, 21….

Examples:

Input: arr[]= {0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0}
Output: 3

The person will jump from:
1) index -1 to index 4 (a distance of jump = 5)
2) index 4 to index 6 (a distance of jump = 2)
3) index 6 to the destination (a distance of jump = 5)

Input: arr[]= {0, 0}
Output: 1

The person will jump from:
1) index -1 to destination (a distance of jump = 3)

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

Approach:

First, we will create an array fib[] for storing fibonacci numbers.
Then, we will create a DP array and initialize it with INT_MAX and the 0th index DP[0] = 0 and will move in the same way as Coin Change Problem with minimum number of coins.

The DP definition and recurrence is as followed:

 
 DP[i] = min( DP[i], 1 + DP[i-fib[j]] )

where i is the current index and j denotes
the jth fibonacci number of which the
jump is possible

Here DP[i] denotes the minimum steps required to reach index i considering all Fibonacci numbers.

Below is the implementation of the approach:

C++

// A Dynamic Programming based 
// C++ program to find minimum 
// number of jumps to reach 
// Destination 
#include <bits/stdc++.h> 
using namespace std; 
#define MAX 1e9 
  
// Function that returns the min 
// number of jump to reach the 
// destination 
int minJumps(int arr[], int N) 
{ 
    // We consider only those Fibonacci 
    // numbers which are less than n, 
    // where we can consider fib[30] 
    // to be the upper bound as this 
    // will cross 10^5 
    int fib[30]; 
    fib[0] = 0; 
    fib[1] = 1; 
    for (int i = 2; i < 30; i++) 
        fib[i] = fib[i - 1] + fib[i - 2]; 
  
    // DP[i] will be storing the minimum 
    // number of jumps required for 
    // the position i. So DP[N+1] will 
    // have the result we consider 0 
    // as source and N+1 as the destination 
    int DP[N + 2]; 
  
    // Base case (Steps to reach source is) 
    DP[0] = 0; 
  
    // Initialize all table values as Infinite 
    for (int i = 1; i <= N + 1; i++) 
        DP[i] = MAX; 
  
    // Compute minimum jumps required 
    // considering each Fibonacci 
    // numbers one by one. 
  
    // Go through each positions 
    // till destination. 
    for (int i = 1; i <= N + 1; i++) { 
  
        // Calculate the minimum of that 
        // position if all the Fibonacci 
        // numbers are considered 
        for (int j = 1; j < 30; j++) { 
  
            // If the position is safe 
            // or the position is the 
            // destination then only we 
            // calculate the minimum 
            // otherwise the cost is 
            // MAX as default 
            if ((arr[i - 1] == 1 
                 || i == N + 1) 
                && i - fib[j] >= 0) 
                DP[i] = min(DP[i], 
                            1 + DP[i - fib[j]]); 
        } 
    } 
  
    // -1 denotes if there is 
    // no path possible 
    if (DP[N + 1] != MAX) 
        return DP[N + 1]; 
    else
        return -1; 
} 
  
// Driver program to test above function 
int main() 
{ 
    int arr[] = { 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 
  
    cout << minJumps(arr, n); 
    return 0; 
} 

Java

// A Dynamic Programming based  
// Java program to find minimum  
// number of jumps to reach  
// Destination 
import java.util.*;  
import java.lang.*;  
  
class GFG  
{ 
      
// Function that returns the min  
// number of jump to reach the  
// destination 
public static int minJumps(int arr[], int N)  
{ 
    int MAX = 1000000; 
      
    // We consider only those Fibonacci  
    // numbers which are less than n,  
    // where we can consider fib[30]  
    // to be the upper bound as this  
    // will cross 10^5  
    int[] fib = new int[30];  
    fib[0] = 0;  
    fib[1] = 1; 
      
    for (int i = 2; i < 30; i++)  
    fib[i] = fib[i - 1] + fib[i - 2];  
      
    // DP[i] will be storing the minimum  
    // number of jumps required for  
    // the position i. So DP[N+1] will  
    // have the result we consider 0  
    // as source and N+1 as the destination  
    int[] DP = new int[N + 2];  
      
    // Base case (Steps to reach source is)  
    DP[0] = 0;  
  
    // Initialize all table values as Infinite  
    for (int i = 1; i <= N + 1; i++)  
        DP[i] = MAX;  
  
    // Compute minimum jumps required  
    // considering each Fibonacci  
    // numbers one by one.  
  
    // Go through each positions  
    // till destination.  
    for (int i = 1; i <= N + 1; i++) 
    {  
  
        // Calculate the minimum of that  
        // position if all the Fibonacci  
        // numbers are considered  
        for (int j = 1; j < 30; j++)  
        {  
  
            // If the position is safe  
            // or the position is the  
            // destination then only we  
            // calculate the minimum  
            // otherwise the cost is  
            // MAX as default  
            if ((i == N + 1 ||  
                 arr[i - 1] == 1) && 
                 i - fib[j] >= 0)  
                DP[i] = Math.min(DP[i], 1 + 
                                 DP[i - fib[j]]);  
        }  
    }  
  
    // -1 denotes if there is  
    // no path possible  
    if (DP[N + 1] != MAX)  
        return DP[N + 1];  
    else
        return -1;  
}  
  
// Driver Code  
public static void main (String[] args)  
{  
    int[] arr = new int[]{ 0, 0, 0, 1, 1, 0, 
                              1, 0, 0, 0, 0 };  
    int n = 11;  
    int ans = minJumps(arr, n);  
    System.out.println(ans);  
} 
} 
  
// This code is contributed by Mehul 

Python3

# A Dynamic Programming based Python3 program  
# to find minimum number of jumps to reach 
# Destination 
MAX = 1e9
  
# Function that returns the min number  
# of jump to reach the destination 
def minJumps(arr, N): 
      
    # We consider only those Fibonacci 
    # numbers which are less than n, 
    # where we can consider fib[30] 
    # to be the upper bound as this 
    # will cross 10^5 
    fib = [0 for i in range(30)] 
    fib[0] = 0
    fib[1] = 1
    for i in range(2, 30): 
        fib[i] = fib[i - 1] + fib[i - 2] 
  
    # DP[i] will be storing the minimum 
    # number of jumps required for 
    # the position i. So DP[N+1] will 
    # have the result we consider 0 
    # as source and N+1 as the destination 
    DP = [0 for i in range(N + 2)] 
  
    # Base case (Steps to reach source is) 
    DP[0] = 0
  
    # Initialize all table values as Infinite 
    for i in range(1, N + 2): 
        DP[i] = MAX
  
    # Compute minimum jumps required 
    # considering each Fibonacci 
    # numbers one by one. 
  
    # Go through each positions 
    # till destination. 
    for i in range(1, N + 2): 
  
        # Calculate the minimum of that 
        # position if all the Fibonacci 
        # numbers are considered 
        for j in range(1, 30): 
  
            # If the position is safe or the  
            # position is the destination then  
            # only we calculate the minimum 
            # otherwise the cost is MAX as default 
            if ((arr[i - 1] == 1 or i == N + 1) and 
                                    i - fib[j] >= 0): 
                DP[i] = min(DP[i], 1 + DP[i - fib[j]]) 
  
    # -1 denotes if there is 
    # no path possible 
    if (DP[N + 1] != MAX): 
        return DP[N + 1] 
    else: 
        return -1
  
# Driver Code 
arr = [0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0] 
n = len(arr) 
  
print(minJumps(arr, n - 1)) 
  
# This code is contributed by Mohit Kumar 

C#

// A Dynamic Programming based  
// C# program to find minimum  
// number of jumps to reach  
// Destination 
using System; 
using System.Collections.Generic; 
  
class GFG  
{ 
      
// Function that returns the min  
// number of jump to reach the  
// destination 
public static int minJumps(int []arr, int N)  
{ 
    int MAX = 1000000; 
      
    // We consider only those Fibonacci  
    // numbers which are less than n,  
    // where we can consider fib[30]  
    // to be the upper bound as this  
    // will cross 10^5  
    int[] fib = new int[30];  
    fib[0] = 0;  
    fib[1] = 1; 
      
    for (int i = 2; i < 30; i++)  
    fib[i] = fib[i - 1] + fib[i - 2];  
      
    // DP[i] will be storing the minimum  
    // number of jumps required for  
    // the position i. So DP[N+1] will  
    // have the result we consider 0  
    // as source and N+1 as the destination  
    int[] DP = new int[N + 2];  
      
    // Base case (Steps to reach source is)  
    DP[0] = 0;  
  
    // Initialize all table values as Infinite  
    for (int i = 1; i <= N + 1; i++)  
        DP[i] = MAX;  
  
    // Compute minimum jumps required  
    // considering each Fibonacci  
    // numbers one by one.  
  
    // Go through each positions  
    // till destination.  
    for (int i = 1; i <= N + 1; i++) 
    {  
  
        // Calculate the minimum of that  
        // position if all the Fibonacci  
        // numbers are considered  
        for (int j = 1; j < 30; j++)  
        {  
  
            // If the position is safe  
            // or the position is the  
            // destination then only we  
            // calculate the minimum  
            // otherwise the cost is  
            // MAX as default  
            if ((i == N + 1 ||  
                arr[i - 1] == 1) && 
                i - fib[j] >= 0)  
                DP[i] = Math.Min(DP[i], 1 + 
                                 DP[i - fib[j]]);  
        }  
    }  
  
    // -1 denotes if there is  
    // no path possible  
    if (DP[N + 1] != MAX)  
        return DP[N + 1];  
    else
        return -1;  
}  
  
// Driver Code  
public static void Main (String[] args)  
{  
    int[] arr = new int[]{ 0, 0, 0, 1, 1, 0, 
                              1, 0, 0, 0, 0 };  
    int n = 11;  
    int ans = minJumps(arr, n);  
    Console.WriteLine(ans);  
} 
} 
  
// This code is contributed by Princi Singh 

Output:

Time Complexity: $O(Nlog(N))$

My Personal Notes

Suggest a Topic

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

C++

Java

Python3

C#

Recommended Posts: