求在恰好 k 次跳跃中到达最后一个岛所需的最小跳跃长度

给定一个整数数组arr[] ，其中第i^个整数表示存在岛的位置，以及整数k (1 ≤ k < N)。一个人站在第0^个岛上，必须到达最后一个岛，通过从一个岛跳到另一个岛正好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 次跳跃中到达数组的末尾，其中选择跳跃的任何两个岛之间的最大距离小于或等于distance 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 ihritik

C#

// 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 */

Javascript

// Javascript implementation of the approach
 
  
    // Function that returns true if it is possible
    // to reach end of the array in exactly k jumps
    function isPossible(arr, n, dist, k)
    {
   
        // Variable to store the number of
        // steps required to reach the end
        let req = 0;
   
        let curr = 0;
        let prev = 0;
   
        for (let 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
    function minDistance(arr, n, k)
    {
        let l = 0;
        let h = arr[n - 1];
   
        // Stores the answer
        let ans = 0;
   
        // Binary search to calculate the result
        while (l <= h)
        {
            let m = Math.floor((l + h) / 2);
            if (isPossible(arr, n, m, k))
            {
                ans = m;
                h = m - 1;
            }
            else
            {
                l = m + 1;
            }
        }
   
        return ans;
    }
       
 
// Driver Code
 
        let arr = [2, 15, 36, 43];
        let n = arr.length;
        let k = 2;
   
         document.write(minDistance(arr, n, k));
           

输出：

28

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。