给定一个0和1s数组，如果任何特定索引i的值为1，则它是一个安全索引，如果该值为0，则它是一个不安全的索引。站在索引-1 (源)上的男人只能降落在安全索引上，并且他必须达到第N个索引(最后一个位置)。在每次跳跃时，该人只能行驶等于任何斐波那契数的距离。您必须将步数降到最低，前提是人只能向前跳跃。
注意：前几个斐波那契数是– 0、1、1、2、3、5、8、13、21…。
例子：
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)
方法：
- 首先，我们将创建一个数组fib []来存储斐波那契数。
- 然后，我们将创建一个DP数组，并使用INT_MAX和第0个索引DP [0] = 0对其进行初始化，并将以与最少硬币数量的硬币更改问题相同的方式移动。
- DP的定义和重复性如下：
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 - 在这里，DP [i]表示考虑所有斐波纳契数的指数i所需的最小步长。
下面是该方法的实现：
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[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 MehulPython3
# 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 KumarC#
// 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
时间复杂度： 