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)

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

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

JavaScript

<script>

// A Dynamic Programming based
// Javascript program to find minimum
// number of jumps to reach
// Destination

const MAX = 1000000000;

// Function that returns the min
// number of jump to reach the
// destination
function 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
    let fib = new Array(30);
    fib[0] = 0;
    fib[1] = 1;
    for (let 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
    let DP = new Array(N + 2);

    // Base case (Steps to reach source is)
    DP[0] = 0;

    // Initialize all table values as Infinite
    for (let 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 (let i = 1; i <= N + 1; i++) {

        // Calculate the minimum of that
        // position if all the Fibonacci
        // numbers are considered
        for (let 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] = 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 program to test above function
    let arr = [ 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0 ];
    let n = arr.length;

    document.write(minJumps(arr, n));

</script>

Output:

Time Complexity: O(Nlog(N))

Minimum number of Fibonacci jumps to reach end

Explore