Maximum of minimum difference of all pairs from subsequences of given size

• Difficulty Level : Hard
• Last Updated : 16 Aug, 2021

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:
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++

 // C++ Program to implement // the above approach #include using namespace std;   // Function to check a subsequence can // be formed with min difference mid bool can_place(int A[], int n,                int B, int mid) {     int count = 1;     int last_position = A;       // If a subsequence of size B     // with min diff = mid is possible     // return true else false     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; }   // Function to find the maximum of // all minimum difference of pairs // possible among the subsequence int find_min_difference(int A[],                         int n, int B) {       // Sort the Array     sort(A, A + n);       // Stores the boundaries     // of the search space     int s = 0;     int e = A[n - 1] - A;       // Store the answer     int ans = 0;       // Binary Search     while (s <= e) {           long long int mid = (s + e) / 2;           // If subsequence can be formed         // with min diff mid and size B         if (can_place(A, n, B, mid)) {             ans = mid;               // Right half             s = mid + 1;         }         else {               // Left half             e = mid - 1;         }     }       return ans; }   // Driver Code int main() {     int A[] = { 1, 2, 3, 5 };     int n = sizeof(A) / sizeof(A);     int B = 3;       int min_difference         = find_min_difference(A, n, B);     cout << min_difference;     return 0; }

Java

 // Java program to implement // the above approach import java.util.*;   class GFG{   // Function to check a subsequence can // be formed with min difference mid static boolean can_place(int A[], int n,                          int B, int mid) {     int count = 1;     int last_position = A;       // If a subsequence of size B     // with min diff = mid is possible     // return true else false     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; }   // Function to find the maximum of // all minimum difference of pairs // possible among the subsequence static int find_min_difference(int A[],                         int n, int B) {       // Sort the Array     Arrays.sort(A);       // Stores the boundaries     // of the search space     int s = 0;     int e = A[n - 1] - A;       // Store the answer     int ans = 0;       // Binary Search     while (s <= e)     {         int mid = (s + e) / 2;           // If subsequence can be formed         // with min diff mid and size B         if (can_place(A, n, B, mid))         {             ans = mid;               // Right half             s = mid + 1;         }         else         {                           // Left half             e = mid - 1;         }     }     return ans; }   // Driver Code 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); } }   // This code is contributed by 29AjayKumar

Python3

 # Python3 program to implement # the above approach   # Function to check a subsequence can # be formed with min difference mid def can_place(A, n, B, mid):       count = 1     last_position = A       # If a subsequence of size B     # with min diff = mid is possible     # return true else false     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)   # Function to find the maximum of # all minimum difference of pairs # possible among the subsequence def find_min_difference(A, n, B):       # Sort the Array     A.sort()       # Stores the boundaries     # of the search space     s = 0     e = A[n - 1] - A       # Store the answer     ans = 0       # Binary Search     while (s <= e):         mid = (int)((s + e) / 2)           # If subsequence can be formed         # with min diff mid and size B         if (can_place(A, n, B, mid)):             ans = mid               # Right half             s = mid + 1                   else:               # Left half             e = mid - 1           return ans   # Driver code A = [ 1, 2, 3, 5 ] n = len(A) B = 3   min_difference = find_min_difference(A, n, B)   print(min_difference)   # This code is contributed by divyeshrabadiya07

C#

 // C# program to implement // the above approach using System; class GFG{    // Function to check a subsequence can // be formed with min difference mid static bool can_place(int[] A, int n,                       int B, int mid) {     int count = 1;     int last_position = A;        // If a subsequence of size B     // with min diff = mid is possible     // return true else false     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; }    // Function to find the maximum of // all minimum difference of pairs // possible among the subsequence static int find_min_difference(int[] A,                         int n, int B) {        // Sort the Array     Array.Sort(A);        // Stores the boundaries     // of the search space     int s = 0;     int e = A[n - 1] - A;        // Store the answer     int ans = 0;        // Binary Search     while (s <= e)     {         int mid = (s + e) / 2;            // If subsequence can be formed         // with min diff mid and size B         if (can_place(A, n, B, mid))         {             ans = mid;                // Right half             s = mid + 1;         }         else         {                            // Left half             e = mid - 1;         }     }     return ans; }    // Driver Code 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); } }    // This code is contributed by rock_cool

Javascript



Output:

2

Time Complexity: O(NlogN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :