Maximum of minimum difference of all pairs from subsequences of given size
Given an integer array A[ ] of size N, the task is to find a subsequence of size B such that the minimum difference between any two of them is maximum and print this largest minimum difference.
Examples:
Input: A[ ] = {1, 2, 3, 5}, B = 3
Output: 2
Explanation:
Possible subsequences of size 3 are {1, 2, 3}, {1, 2, 5}, {1, 3, 5} and {2, 3, 5}.
For {1, 3, 5}, possible differences are (|1 – 3| = 2), (|3 – 5| = 2) and (|1 – 5| = 4), Minimum(2, 2, 4) = 2
For the remaining subsequences, the minimum difference comes out to be 1.
Hence, the maximum of all minimum differences is 2.
Input: A[ ] = {5, 17, 11}, B = 2
Output: 12
Explanation:
Possible subsequences of size 2 are {5, 17}, {17, 11} and {5, 11}.
For {5, 17}, possible difference is (|5 – 17| = 12), Minimum = 12
For {17, 11}, possible difference is (|17 – 11| = 6), Minimum = 6
For {5, 11}, possible difference is (|5 – 11| = 6), Minimum = 6
Maximum(12, 6, 6) = 12
Hence, the maximum of all minimum differences is 12.
Naive Approach:
The simplest approach to solve this problem is to generate all possible subsequences of size B and find the minimum difference among all possible pairs. Finally, find the maximum among all the minimum differences.
Time complexity: O(2N*N2)
Auxiliary Space: O(N)
Efficient Approach:
Follow the steps below to optimize the above approach using Binary Search:
- Set the search space from 0 to maximum element in the array(maxm)
- For each calculated mid, check whether it is possible to get a subsequence of size B with a minimum difference among any pair equal to mid.
- If it is possible, then store mid in a variable and find a better answer in the right half and discard the left half of the mid
- Otherwise, traverse the left half of the mid, to check if a subsequence with smaller minimum difference of pairs exists.
- Finally, after termination of the binary search, print the highest mid for which any subsequence with minimum difference of pairs equal to mid was found.
Illustration:
A[ ] = {1, 2, 3, 4, 5}, B = 3
Search space: {0, 1, 2, 3, 4, 5}
Steps involved in binary search are as follows:
- start = 0, end = 5, mid = (0 + 5) / 2 = 2
Subsequence of size B with minimum difference of mid(= 2) is {1, 3, 5}.
Therefore, ans = 2
- Now, traverse the right half.
start = mid +1 = 3, end = 5, mid = (3 + 5) / 2 = 4
Subsequence of size B with minimum difference of mid(= 4) is not possible.
Therefore, ans is still 2.
- Now, traverse the left half
start = 3, end = mid – 1 = 3, mid = (3 + 3) / 2 = 3
Subsequence of size B with minimum difference of mid(= 3) is not possible.
Therefore, ans is still 2.
- Again, traverse left half.
start = 3, end = mid – 1 = 2.
Since start exceeds end, binary search terminates.
- Finally, the largest possible minimum difference is 2.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool can_place( int A[], int n,
int B, int mid)
{
int count = 1;
int last_position = A[0];
for ( int i = 1; i < n; i++) {
if (A[i] - last_position
>= mid) {
last_position = A[i];
count++;
if (count == B) {
return true ;
}
}
}
return false ;
}
int find_min_difference( int A[],
int n, int B)
{
sort(A, A + n);
int s = 0;
int e = A[n - 1] - A[0];
int ans = 0;
while (s <= e) {
long long int mid = (s + e) / 2;
if (can_place(A, n, B, mid)) {
ans = mid;
s = mid + 1;
}
else {
e = mid - 1;
}
}
return ans;
}
int main()
{
int A[] = { 1, 2, 3, 5 };
int n = sizeof (A) / sizeof (A[0]);
int B = 3;
int min_difference
= find_min_difference(A, n, B);
cout << min_difference;
return 0;
}
|
Java
import java.util.*;
class GFG{
static boolean can_place( int A[], int n,
int B, int mid)
{
int count = 1 ;
int last_position = A[ 0 ];
for ( int i = 1 ; i < n; i++)
{
if (A[i] - last_position >= mid)
{
last_position = A[i];
count++;
if (count == B)
{
return true ;
}
}
}
return false ;
}
static int find_min_difference( int A[],
int n, int B)
{
Arrays.sort(A);
int s = 0 ;
int e = A[n - 1 ] - A[ 0 ];
int ans = 0 ;
while (s <= e)
{
int mid = (s + e) / 2 ;
if (can_place(A, n, B, mid))
{
ans = mid;
s = mid + 1 ;
}
else
{
e = mid - 1 ;
}
}
return ans;
}
public static void main(String[] args)
{
int A[] = { 1 , 2 , 3 , 5 };
int n = A.length;
int B = 3 ;
int min_difference = find_min_difference(A, n, B);
System.out.print(min_difference);
}
}
|
Python3
def can_place(A, n, B, mid):
count = 1
last_position = A[ 0 ]
for i in range ( 1 , n):
if (A[i] - last_position > = mid):
last_position = A[i]
count = count + 1
if (count = = B):
return bool ( True )
return bool ( False )
def find_min_difference(A, n, B):
A.sort()
s = 0
e = A[n - 1 ] - A[ 0 ]
ans = 0
while (s < = e):
mid = ( int )((s + e) / 2 )
if (can_place(A, n, B, mid)):
ans = mid
s = mid + 1
else :
e = mid - 1
return ans
A = [ 1 , 2 , 3 , 5 ]
n = len (A)
B = 3
min_difference = find_min_difference(A, n, B)
print (min_difference)
|
C#
using System;
class GFG{
static bool can_place( int [] A, int n,
int B, int mid)
{
int count = 1;
int last_position = A[0];
for ( int i = 1; i < n; i++)
{
if (A[i] - last_position >= mid)
{
last_position = A[i];
count++;
if (count == B)
{
return true ;
}
}
}
return false ;
}
static int find_min_difference( int [] A,
int n, int B)
{
Array.Sort(A);
int s = 0;
int e = A[n - 1] - A[0];
int ans = 0;
while (s <= e)
{
int mid = (s + e) / 2;
if (can_place(A, n, B, mid))
{
ans = mid;
s = mid + 1;
}
else
{
e = mid - 1;
}
}
return ans;
}
public static void Main( string [] args)
{
int [] A = { 1, 2, 3, 5 };
int n = A.Length;
int B = 3;
int min_difference = find_min_difference(A, n, B);
Console.Write(min_difference);
}
}
|
Javascript
<script>
function can_place(A, n, B, mid)
{
let count = 1;
let last_position = A[0];
for (let i = 1; i < n; i++)
{
if (A[i] - last_position >= mid)
{
last_position = A[i];
count++;
if (count == B)
{
return true ;
}
}
}
return false ;
}
function find_min_difference(A, n, B)
{
A.sort();
let s = 0;
let e = A[n - 1] - A[0];
let ans = 0;
while (s <= e)
{
let mid = parseInt((s + e) / 2, 10);
if (can_place(A, n, B, mid))
{
ans = mid;
s = mid + 1;
}
else
{
e = mid - 1;
}
}
return ans;
}
let A = [ 1, 2, 3, 5 ];
let n = A.length;
let B = 3;
let min_difference = find_min_difference(A, n, B);
document.write(min_difference);
</script>
|
Time Complexity: O(NlogN)
Auxiliary Space: O(1)
Last Updated :
16 Aug, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...