将囚犯放入牢房，以最大化任何两个人之间的最小差异

给定一个由N 个元素组成的数组cell[] ，代表牢房中牢房的位置。此外，给定一个整数P ，即囚犯的数量，任务是以有序的方式将所有囚犯放置在牢房中，使得任意两个囚犯之间的最小距离尽可能大。最后，打印最大距离。
例子：

Input: cell[] = {1, 2, 8, 4, 9}, P = 3
Output: 3
The three prisoners will be placed at the cells
numbered 1, 4 and 8 with the minimum distance 3
which is the maximum possible.
Input: cell[] = {10, 12, 18}, P = 2
Output: 8
The three possible placements are {10, 12}, {10, 18} and {12, 18}.

编程需要懂一点英语

方法：这个问题可以使用二分查找来解决。由于关押囚犯的两个牢房之间的最小距离必须最大化，搜索空间将是距离，从0开始(如果两个囚犯关在同一个牢房中)到牢房 [N – 1] – 结束牢房[0] (如果一个囚犯被关在第一个牢房，另一个被关在最后一个牢房)。
初始化L = 0和R = cell[N – 1] – cell[0]然后应用二分查找。对于每个mid ，检查是否可以放置囚犯以使任何两个囚犯之间的最小距离至少为mid 。

如果是，则尝试增加此距离以最大化答案并再次检查。
如果不是，则尝试减少距离。
最后，打印最大距离。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function that returns true if the prisoners
// can be placed such that the minimum distance
// between any two prisoners is at least sep
bool canPlace(int a[], int n, int p, int sep)
{
    // Considering the first prisoner
    // is placed at 1st cell
    int prisoners_placed = 1;
 
    // If the first prisoner is placed at
    // the first cell then the last_prisoner_placed
    // will be the first prisoner placed
    // and that will be in cell[0]
    int last_prisoner_placed = a[0];
 
    for (int i = 1; i < n; i++) {
        int current_cell = a[i];
 
        // Checking if the prisoner can be
        // placed at ith cell or not
        if (current_cell - last_prisoner_placed >= sep) {
            prisoners_placed++;
            last_prisoner_placed = current_cell;
 
            // If all the prisoners got placed
            // then return true
            if (prisoners_placed == p) {
                return true;
            }
        }
    }
 
    return false;
}
 
// Function to return the maximized distance
int maxDistance(int cell[], int n, int p)
{
 
    // Sort the array so that binary
    // search can be applied on it
    sort(cell, cell + n);
 
    // Minimum possible distance
    // for the search space
    int start = 0;
 
    // Maximum possible distance
    // for the search space
    int end = cell[n - 1] - cell[0];
 
    // To store the result
    int ans = 0;
 
    // Binary search
    while (start <= end) {
        int mid = start + ((end - start) / 2);
 
        // If the prisoners can be placed such that
        // the minimum distance between any two
        // prisoners is at least mid
        if (canPlace(cell, n, p, mid)) {
 
            // Update the answer
            ans = mid;
            start = mid + 1;
        }
        else {
            end = mid - 1;
        }
    }
 
    return ans;
}
 
// Driver code
int main()
{
    int cell[] = { 1, 2, 8, 4, 9 };
    int n = sizeof(cell) / sizeof(int);
    int p = 3;
 
    cout << maxDistance(cell, n, p);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
    // Function that returns true if the prisoners
    // can be placed such that the minimum distance
    // between any two prisoners is at least sep
    static boolean canPlace(int a[], int n, int p, int sep)
    {
        // Considering the first prisoner
        // is placed at 1st cell
        int prisoners_placed = 1;
     
        // If the first prisoner is placed at
        // the first cell then the last_prisoner_placed
        // will be the first prisoner placed
        // and that will be in cell[0]
        int last_prisoner_placed = a[0];
     
        for (int i = 1; i < n; i++)
        {
            int current_cell = a[i];
     
            // Checking if the prisoner can be
            // placed at ith cell or not
            if (current_cell - last_prisoner_placed >= sep)
            {
                prisoners_placed++;
                last_prisoner_placed = current_cell;
     
                // If all the prisoners got placed
                // then return true
                if (prisoners_placed == p)
                {
                    return true;
                }
            }
        }
     
        return false;
    }
     
    // Function to return the maximized distance
    static int maxDistance(int cell[], int n, int p)
    {
     
        // Sort the array so that binary
        // search can be applied on it
        Arrays.sort(cell);
     
        // Minimum possible distance
        // for the search space
        int start = 0;
     
        // Maximum possible distance
        // for the search space
        int end = cell[n - 1] - cell[0];
     
        // To store the result
        int ans = 0;
     
        // Binary search
        while (start <= end)
        {
            int mid = start + ((end - start) / 2);
     
            // If the prisoners can be placed such that
            // the minimum distance between any two
            // prisoners is at least mid
            if (canPlace(cell, n, p, mid))
            {
     
                // Update the answer
                ans = mid;
                start = mid + 1;
            }
            else
            {
                end = mid - 1;
            }
        }
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int cell[] = { 1, 2, 8, 4, 9 };
        int n = cell.length;
        int p = 3;
     
        System.out.println(maxDistance(cell, n, p));
     
    }
}
 
// This code is contributed by AnkitRai01

Python3

# Python3 implementation of the approach
 
# Function that returns true if the prisoners
# can be placed such that the minimum distance
# between any two prisoners is at least sep
def canPlace(a, n, p, sep):
     
    # Considering the first prisoner
    # is placed at 1st cell
    prisoners_placed = 1
 
    # If the first prisoner is placed at
    # the first cell then the last_prisoner_placed
    # will be the first prisoner placed
    # and that will be in cell[0]
    last_prisoner_placed = a[0]
 
    for i in range(1, n):
        current_cell = a[i]
 
        # Checking if the prisoner can be
        # placed at ith cell or not
        if (current_cell - last_prisoner_placed >= sep):
            prisoners_placed += 1
            last_prisoner_placed = current_cell
 
            # If all the prisoners got placed
            # then return true
            if (prisoners_placed == p):
                return True
 
    return False
 
# Function to return the maximized distance
def maxDistance(cell, n, p):
 
    # Sort the array so that binary
    # search can be applied on it
    cell = sorted(cell)
 
    # Minimum possible distance
    # for the search space
    start = 0
 
    # Maximum possible distance
    # for the search space
    end = cell[n - 1] - cell[0]
 
    # To store the result
    ans = 0
 
    # Binary search
    while (start <= end):
        mid = start + ((end - start) // 2)
 
        # If the prisoners can be placed such that
        # the minimum distance between any two
        # prisoners is at least mid
        if (canPlace(cell, n, p, mid)):
 
            # Update the answer
            ans = mid
            start = mid + 1
        else :
            end = mid - 1
 
    return ans
 
# Driver code
cell= [1, 2, 8, 4, 9]
n = len(cell)
p = 3
 
print(maxDistance(cell, n, p))
 
# This code is contributed by mohit kumar 29

C#

// C# implementation of the approach
using System;
using System.Collections;
 
class GFG
{
 
    // Function that returns true if the prisoners
    // can be placed such that the minimum distance
    // between any two prisoners is at least sep
    static bool canPlace(int []a, int n,
                         int p, int sep)
    {
        // Considering the first prisoner
        // is placed at 1st cell
        int prisoners_placed = 1;
     
        // If the first prisoner is placed at
        // the first cell then the last_prisoner_placed
        // will be the first prisoner placed
        // and that will be in cell[0]
        int last_prisoner_placed = a[0];
     
        for (int i = 1; i < n; i++)
        {
            int current_cell = a[i];
     
            // Checking if the prisoner can be
            // placed at ith cell or not
            if (current_cell - last_prisoner_placed >= sep)
            {
                prisoners_placed++;
                last_prisoner_placed = current_cell;
     
                // If all the prisoners got placed
                // then return true
                if (prisoners_placed == p)
                {
                    return true;
                }
            }
        }
        return false;
    }
     
    // Function to return the maximized distance
    static int maxDistance(int []cell, int n, int p)
    {
     
        // Sort the array so that binary
        // search can be applied on it
        Array.Sort(cell);
     
        // Minimum possible distance
        // for the search space
        int start = 0;
     
        // Maximum possible distance
        // for the search space
        int end = cell[n - 1] - cell[0];
     
        // To store the result
        int ans = 0;
     
        // Binary search
        while (start <= end)
        {
            int mid = start + ((end - start) / 2);
     
            // If the prisoners can be placed such that
            // the minimum distance between any two
            // prisoners is at least mid
            if (canPlace(cell, n, p, mid))
            {
     
                // Update the answer
                ans = mid;
                start = mid + 1;
            }
            else
            {
                end = mid - 1;
            }
        }
        return ans;
    }
     
    // Driver code
    public static void Main()
    {
        int []cell = { 1, 2, 8, 4, 9 };
        int n = cell.Length;
        int p = 3;
     
        Console.WriteLine(maxDistance(cell, n, p));
    }
}
 
// This code is contributed by AnkitRai01

Javascript

输出：

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