# Minimum number of Fibonacci jumps to reach end

• Difficulty Level : Hard
• Last Updated : 07 Jun, 2021

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 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 ``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``    ``// to be the upper bound as this``    ``// will cross 10^5``    ``int` `fib;``    ``fib = 0;``    ``fib = 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;`` ` `    ``// 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);`` ` `    ``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 ``    ``// 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``    ``# 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 ``    ``// to be the upper bound as this ``    ``// will cross 10^5 ``    ``int``[] fib = ``new` `int``; ``    ``fib = 0; ``    ``fib = 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; `` ` `    ``// 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

 ``

Output:

`3`

Time Complexity: My Personal Notes arrow_drop_up