给定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] – cell [0] (如果一个囚犯被关在第一个牢房中，而另一个囚犯被关在最后一个牢房中)。
初始化L = 0和R = cell [N – 1] – cell [0]，然后应用二进制搜索。对于每个中间，请检查囚犯的放置位置，以确保任何两个囚犯之间的最小距离至少为中间
- 如果是，则尝试增加此距离以最大化答案并再次检查。
- 如果没有，请尝试减小距离。
- 最后，打印最大距离。
下面是上述方法的实现：
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 AnkitRai01Python3
# 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 29C#
// 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 AnkitRai01Javascript
输出：
3