# Place the prisoners into cells to maximize the minimum difference between any two

Given an array cell[] of N elements, which represent the positions of the cells in a prison. Also, given an integer P which is the number of prisoners, the task is to place all the prisoners in the cells in an ordered manner such that the minimum distance between any two prisoners is as large as possible. Finally, print the maximized distance.

Examples:

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}.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: This problem can be solved using binary search. As the minimum distance between two cells in which prisoners will be kept has to be maximized, the search space will be of distance, starting from 0 (if two prisoners are kept in the same cell) and ending at cell[N – 1] – cell (if one prisoner is kept in the first cell, and the other one is kept in the last cell).
Initialize L = 0 and R = cell[N – 1] – cell then apply the binary search. For every mid, check whther the prisoners can be placed such that the minimum distance between any two prisoners is at least mid

• If yes then try to increase this distance in order to maximize the answer and check again.
• If not then try to decrease the distance.
• Finally, print the maximized distance.

Below is the implementation of the above approach:

## 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 ` `    ``int` `last_prisoner_placed = a; ` ` `  `    ``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; ` ` `  `    ``// 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  ` `        ``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 ` `    ``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  ` `        ``int` `last_prisoner_placed = a;  ` `     `  `        ``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;  ` `     `  `        ``// 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  `

Output:

```3
```

My Personal Notes arrow_drop_up I am a Computer Science Student at JIIT-Noida I have worked for Sanfoundry previously and contributed more than 50 articles

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : mohit kumar 29, AnkitRai01