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: 3The 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: 1The 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 |
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 |
3
Time Complexity:
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.