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

Output:

```3
```

Time Complexity: My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.