给定整数数组arr [] ，其中第i个整数表示存在岛的位置，并且整数k (1≤k
例子：
Input: arr[] = {2, 15, 36, 43}, k = 1
Output: 41
There is only way to reach the end
2 -> 43
Input: arr[] = {2, 15, 36, 43}, k = 2
Output: 28
There are two ways to reach the last island
2 -> 15 -> 43
Here maximum distance between any two consecutive islands is between 43 and 15 that is 28.
2 -> 36 -> 43
Here maximum distance between any two consecutive islands is between 36 and 2 that is 34.
Thus minimum of 28 and 34 is 28.
方法：想法是使用二进制搜索，并且对于距离mid ，计算是否有可能精确地在k个跳跃中到达数组的末尾，其中选择用于跳跃的任何两个岛之间的最大距离小于或等于k。距离mid ，然后检查是否存在小于mid的某个距离，可以通过准确的k次跳跃达到该距离。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
// Function that returns true if it is possible
// to reach end of the array in exactly k jumps
bool isPossible(int arr[], int n, int dist, int k)
{
// Variable to store the number of
// steps required to reach the end
int req = 0;
int curr = 0;
int prev = 0;
for (int i = 0; i < n; i++) {
while (curr != n && arr[curr] - arr[prev] <= dist)
curr++;
req++;
if (curr == n)
break;
prev = curr - 1;
}
if (curr != n)
return false;
// If it is possible to reach the
// end in exactly k jumps
if (req <= k)
return true;
return false;
}
// Returns the minimum maximum distance required
// to reach the end of the array in exactly k jumps
int minDistance(int arr[], int n, int k)
{
int l = 0;
int h = arr[n - 1];
// Stores the answer
int ans = 0;
// Binary search to calculate the result
while (l <= h) {
int m = (l + h) / 2;
if (isPossible(arr, n, m, k)) {
ans = m;
h = m - 1;
}
else
l = m + 1;
}
return ans;
}
// Driver code
int main()
{
int arr[] = { 2, 15, 36, 43 };
int n = sizeof(arr) / sizeof(int);
int k = 2;
cout << minDistance(arr, n, k);
return 0;
} Java
// Java implementation of the approach
class GFG
{
// Function that returns true if it is possible
// to reach end of the array in exactly k jumps
static boolean isPossible(int arr[], int n, int dist, int k)
{
// Variable to store the number of
// steps required to reach the end
int req = 0;
int curr = 0;
int prev = 0;
for (int i = 0; i < n; i++)
{
while (curr != n && arr[curr] - arr[prev] <= dist)
{
curr++;
}
req++;
if (curr == n)
{
break;
}
prev = curr - 1;
}
if (curr != n)
{
return false;
}
// If it is possible to reach the
// end in exactly k jumps
if (req <= k)
{
return true;
}
return false;
}
// Returns the minimum maximum distance required
// to reach the end of the array in exactly k jumps
static int minDistance(int arr[], int n, int k)
{
int l = 0;
int h = arr[n - 1];
// Stores the answer
int ans = 0;
// Binary search to calculate the result
while (l <= h)
{
int m = (l + h) / 2;
if (isPossible(arr, n, m, k))
{
ans = m;
h = m - 1;
}
else
{
l = m + 1;
}
}
return ans;
}
// Driver code
public static void main(String[] args)
{
int arr[] = {2, 15, 36, 43};
int n = arr.length;
int k = 2;
System.out.println(minDistance(arr, n, k));
}
}
/* This code contributed by PrinciRaj1992 */Python3
# Python3 implementation of the approach
# Function that returns true if it is possible
# to reach end of the array in exactly k jumps
def isPossible(arr, n, dist, k) :
# Variable to store the number of
# steps required to reach the end
req = 0
curr = 0
prev = 0
for i in range(0, n):
while (curr != n and (arr[curr] - arr[prev]) <= dist):
curr = curr + 1
req = req + 1
if (curr == n):
break
prev = curr - 1
if (curr != n):
return False
# If it is possible to reach the
# end in exactly k jumps
if (req <= k):
return True
return False
# Returns the minimum maximum distance required
# to reach the end of the array in exactly k jumps
def minDistance(arr, n, k):
l = 0
h = arr[n - 1]
# Stores the answer
ans = 0
# Binary search to calculate the result
while (l <= h):
m = (l + h) // 2;
if (isPossible(arr, n, m, k)):
ans = m
h = m - 1
else:
l = m + 1
return ans
# Driver code
arr = [ 2, 15, 36, 43 ]
n = len(arr)
k = 2
print(minDistance(arr, n, k))
# This code is contributed by ihritikC#
// C# program to implement
// the above approach
using System;
class GFG
{
// Function that returns true if it is possible
// to reach end of the array in exactly k jumps
static bool isPossible(int []arr, int n, int dist, int k)
{
// Variable to store the number of
// steps required to reach the end
int req = 0;
int curr = 0;
int prev = 0;
for (int i = 0; i < n; i++)
{
while (curr != n && arr[curr] - arr[prev] <= dist)
{
curr++;
}
req++;
if (curr == n)
{
break;
}
prev = curr - 1;
}
if (curr != n)
{
return false;
}
// If it is possible to reach the
// end in exactly k jumps
if (req <= k)
{
return true;
}
return false;
}
// Returns the minimum maximum distance required
// to reach the end of the array in exactly k jumps
static int minDistance(int []arr, int n, int k)
{
int l = 0;
int h = arr[n - 1];
// Stores the answer
int ans = 0;
// Binary search to calculate the result
while (l <= h)
{
int m = (l + h) / 2;
if (isPossible(arr, n, m, k))
{
ans = m;
h = m - 1;
}
else
{
l = m + 1;
}
}
return ans;
}
// Driver code
public static void Main(String[] args)
{
int []arr = {2, 15, 36, 43};
int n = arr.Length;
int k = 2;
Console.WriteLine(minDistance(arr, n, k));
}
}
/* This code contributed by PrinciRaj1992 */PHP
输出：
28