# Maximize the minimum difference between any element pair by selecting K elements from given Array

• Difficulty Level : Medium
• Last Updated : 23 Sep, 2021

Given an array of N integers the task is to select K elements out of these N elements in such a way that the minimum difference between each of the K numbers is the Largest. Return the largest minimum difference after choosing any K elements.

Examples:

Input: N = 4, K = 3, arr = [2, 6, 2, 5]
Output: 1
Explanation: 3 elements out of 4 elements are to be selected with a minimum difference as large as possible. Selecting 2, 2, 5 will result in minimum difference as 0. Selecting 2, 5, 6 will result in minimum difference as 6-5=1

Input: N = 7, K = 4, arr = [1, 4, 9, 0, 2, 13, 3]
Output:  4
Explanation:  Selecting 0, 4, 9, 13 will result in minimum difference of 4, which is the largest minimum difference possible

Naive Approach: Generate all the subsets of size K and find the minimum difference in all of them. Then return the maximum among the differences.

Efficient Approach: Given problem can be solved efficiently using binary search on answer technique. Below steps can be followed to solve the problem:

• Sort the array in ascending order
• Initialize minimum answer ans to 1
• Binary search is used on the range 1 to maximum element in array arr
• Variable dif is used to store the largest minimum difference at every iteration
• Helper function is used to check if selection of K elements is possible with minimum difference greater than dif calculated in previous iteration. If possible then true is returned or else false is returned.
• If above function returns:
• True then update ans to dif and left to dif + 1
• False then update right to dif – 1

Below is the implementation of the above binary search approach

## C++

 `// C++ implementation for the above approach` `#include ` `using` `namespace` `std;`   `// To check if selection of K elements` `// is possible such that difference` `// between them is greater than dif` `bool` `isPossibleToSelect(``int` `arr[], ``int` `N,` `                        ``int` `dif, ``int` `K)` `{` `    ``// Selecting first element in the` `    ``// sorted array` `    ``int` `count = 1;`   `    ``// prev is the previously selected` `    ``// element initially at index 0 as` `    ``// first element is already selected` `    ``int` `prev = arr;`   `    ``// Check if selection of K-1 elements` `    ``// from array with a minimum` `    ``// difference of dif is possible` `    ``for` `(``int` `i = 1; i < N; i++) {`   `        ``// If the current element is` `        ``// atleast dif difference apart` `        ``// from the  previously selected` `        ``// element then select the current` `        ``// element and increase the count` `        ``if` `(arr[i] >= (prev + dif)) {` `            ``count++;`   `            ``// If selection of K elements` `            ``// with a min difference of dif` `            ``// is possible then return true` `            ``if` `(count == K)` `                ``return` `true``;`   `            ``// Prev will become current` `            ``// element for the next iteration` `            ``prev = arr[i];` `        ``}` `    ``}` `    ``// If selection of K elements with minimum` `    ``// difference of dif is not possible` `    ``// then return false` `    ``return` `false``;` `}`   `int` `binarySearch(``int` `arr[], ``int` `left,` `                 ``int` `right, ``int` `K, ``int` `N)` `{` `    ``// Minimum largest difference` `    ``// possible is 1` `    ``int` `ans = 1;` `    ``while` `(left <= right) {` `        ``int` `dif = left + (right - left) / 2;`   `        ``// Check if selection of K elements` `        ``// is possible with a minimum` `        ``// difference of dif` `        ``if` `(isPossibleToSelect(arr, N,` `                               ``dif, K)) {`   `            ``// If dif is greater than` `            ``// previous ans we update ans` `            ``ans = max(ans, dif);`   `            ``// Continue to search for better` `            ``// answer. Try finding greater dif` `            ``left = dif + 1;` `        ``}`   `        ``// K elements cannot be selected` `        ``else` `            ``right = dif - 1;` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N, K;` `    ``N = 7, K = 4;` `    ``int` `arr[] = { 1, 4, 9, 0, 2, 13, 3 };`   `    ``// arr should be in a sorted order` `    ``sort(arr, arr + N);`   `    ``cout << binarySearch(arr, 0, arr[N - 1], K, N)` `         ``<< ``"\n"``;` `    ``return` `0;` `}`

## Java

 `// Java implementation for the above approach` `import` `java.io.*;` `import` `java.util.Arrays;`   `class` `GFG{`   `  ``// To check if selection of K elements` `  ``// is possible such that difference` `  ``// between them is greater than dif` `  ``static` `boolean` `isPossibleToSelect(``int` `[]arr, ``int` `N,` `                                    ``int` `dif, ``int` `K)` `  ``{`   `    ``// Selecting first element in the` `    ``// sorted array` `    ``int` `count = ``1``;`   `    ``// prev is the previously selected` `    ``// element initially at index 0 as` `    ``// first element is already selected` `    ``int` `prev = arr[``0``];`   `    ``// Check if selection of K-1 elements` `    ``// from array with a minimum` `    ``// difference of dif is possible` `    ``for` `(``int` `i = ``1``; i < N; i++) {`   `      ``// If the current element is` `      ``// atleast dif difference apart` `      ``// from the  previously selected` `      ``// element then select the current` `      ``// element and increase the count` `      ``if` `(arr[i] >= (prev + dif)) {` `        ``count++;`   `        ``// If selection of K elements` `        ``// with a min difference of dif` `        ``// is possible then return true` `        ``if` `(count == K)` `          ``return` `true``;`   `        ``// Prev will become current` `        ``// element for the next iteration` `        ``prev = arr[i];` `      ``}` `    ``}` `    ``// If selection of K elements with minimum` `    ``// difference of dif is not possible` `    ``// then return false` `    ``return` `false``;` `  ``}`   `  ``static` `int` `binarySearch(``int` `[]arr, ``int` `left,` `                          ``int` `right, ``int` `K, ``int` `N)` `  ``{` `    ``// Minimum largest difference` `    ``// possible is 1` `    ``int` `ans = ``1``;` `    ``while` `(left <= right) {` `      ``int` `dif = left + (right - left) / ``2``;`   `      ``// Check if selection of K elements` `      ``// is possible with a minimum` `      ``// difference of dif` `      ``if` `(isPossibleToSelect(arr, N,` `                             ``dif, K)) {`   `        ``// If dif is greater than` `        ``// previous ans we update ans` `        ``ans = Math.max(ans, dif);`   `        ``// Continue to search for better` `        ``// answer. Try finding greater dif` `        ``left = dif + ``1``;` `      ``}`   `      ``// K elements cannot be selected` `      ``else` `        ``right = dif - ``1``;` `    ``}` `    ``return` `ans;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args) ` `  ``{` `    ``int` `N, K;` `    ``N = ``7``;` `    ``K = ``4``;` `    ``int` `[]arr = { ``1``, ``4``, ``9``, ``0``, ``2``, ``13``, ``3` `};`   `    ``// arr should be in a sorted order` `    ``Arrays.sort(arr);`   `    ``System.out.println(binarySearch(arr, ``0``, arr[N - ``1``], K, N));` `  ``}` `}`   `// This code is contributed by shivanisinghss2110`

## Python3

 `# Python 3 implementation for the above approach`   `# To check if selection of K elements` `# is possible such that difference` `# between them is greater than dif` `def` `isPossibleToSelect(arr, N,` `                       ``dif, K):`   `    ``# Selecting first element in the` `    ``# sorted array` `    ``count ``=` `1`   `    ``# prev is the previously selected` `    ``# element initially at index 0 as` `    ``# first element is already selected` `    ``prev ``=` `arr[``0``]`   `    ``# Check if selection of K-1 elements` `    ``# from array with a minimum` `    ``# difference of dif is possible` `    ``for` `i ``in` `range``(``1``, N):`   `        ``# If the current element is` `        ``# atleast dif difference apart` `        ``# from the  previously selected` `        ``# element then select the current` `        ``# element and increase the count` `        ``if` `(arr[i] >``=` `(prev ``+` `dif)):` `            ``count ``+``=` `1`   `            ``# If selection of K elements` `            ``# with a min difference of dif` `            ``# is possible then return true` `            ``if` `(count ``=``=` `K):` `                ``return` `True`   `            ``# Prev will become current` `            ``# element for the next iteration` `            ``prev ``=` `arr[i]` `    ``# If selection of K elements with minimum` `    ``# difference of dif is not possible` `    ``# then return false` `    ``return` `False`     `def` `binarySearch(arr, left,` `                 ``right, K,  N):` `    ``# Minimum largest difference` `    ``# possible is 1` `    ``ans ``=` `1` `    ``while` `(left <``=` `right):` `        ``dif ``=` `left ``+` `(right ``-` `left) ``/``/` `2`   `        ``# Check if selection of K elements` `        ``# is possible with a minimum` `        ``# difference of dif` `        ``if` `(isPossibleToSelect(arr, N, dif, K)):`   `            ``# If dif is greater than` `            ``# previous ans we update ans` `            ``ans ``=` `max``(ans, dif)`   `            ``# Continue to search for better` `            ``# answer. Try finding greater dif` `            ``left ``=` `dif ``+` `1`   `        ``# K elements cannot be selected` `        ``else``:` `            ``right ``=` `dif ``-` `1`   `    ``return` `ans`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``N ``=` `7` `    ``K ``=` `4` `    ``arr ``=` `[``1``, ``4``, ``9``, ``0``, ``2``, ``13``, ``3``]`   `    ``# arr should be in a sorted order` `    ``arr.sort()`   `    ``print``(binarySearch(arr, ``0``, arr[N ``-` `1``], K, N)` `          ``)`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# implementation for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// To check if selection of K elements` `// is possible such that difference` `// between them is greater than dif` `static` `bool` `isPossibleToSelect(``int` `[]arr, ``int` `N,` `                        ``int` `dif, ``int` `K)` `{` `    ``// Selecting first element in the` `    ``// sorted array` `    ``int` `count = 1;`   `    ``// prev is the previously selected` `    ``// element initially at index 0 as` `    ``// first element is already selected` `    ``int` `prev = arr;`   `    ``// Check if selection of K-1 elements` `    ``// from array with a minimum` `    ``// difference of dif is possible` `    ``for` `(``int` `i = 1; i < N; i++) {`   `        ``// If the current element is` `        ``// atleast dif difference apart` `        ``// from the  previously selected` `        ``// element then select the current` `        ``// element and increase the count` `        ``if` `(arr[i] >= (prev + dif)) {` `            ``count++;`   `            ``// If selection of K elements` `            ``// with a min difference of dif` `            ``// is possible then return true` `            ``if` `(count == K)` `                ``return` `true``;`   `            ``// Prev will become current` `            ``// element for the next iteration` `            ``prev = arr[i];` `        ``}` `    ``}` `    ``// If selection of K elements with minimum` `    ``// difference of dif is not possible` `    ``// then return false` `    ``return` `false``;` `}`   `static` `int` `binarySearch(``int` `[]arr, ``int` `left,` `                 ``int` `right, ``int` `K, ``int` `N)` `{` `    ``// Minimum largest difference` `    ``// possible is 1` `    ``int` `ans = 1;` `    ``while` `(left <= right) {` `        ``int` `dif = left + (right - left) / 2;`   `        ``// Check if selection of K elements` `        ``// is possible with a minimum` `        ``// difference of dif` `        ``if` `(isPossibleToSelect(arr, N,` `                               ``dif, K)) {`   `            ``// If dif is greater than` `            ``// previous ans we update ans` `            ``ans = Math.Max(ans, dif);`   `            ``// Continue to search for better` `            ``// answer. Try finding greater dif` `            ``left = dif + 1;` `        ``}`   `        ``// K elements cannot be selected` `        ``else` `            ``right = dif - 1;` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `public` `static` `void` `Main()` `{` `    ``int` `N, K;` `    ``N = 7;` `     ``K = 4;` `    ``int` `[]arr = { 1, 4, 9, 0, 2, 13, 3 };`   `    ``// arr should be in a sorted order` `    ``Array.Sort(arr);`   `    ``Console.Write(binarySearch(arr, 0, arr[N - 1], K, N));` `}` `}`   `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output

`4`

Time complexity: O(N * log N)
Space complexity: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :