Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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 <bits/stdc++.h>
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[0];
 
    // 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[0];
 
    // 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[0]);
    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[0];
 
    // 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[0];
 
    // 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[0]
 
    # 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[0]
 
    # 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[0];
  
    // 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[0];
  
    // 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




<script>
 
// Javascript program to implement
// the above approach
 
// Function to check a subsequence can
// be formed with min difference mid
function can_place(A, n, B, mid)
{
    let count = 1;
    let last_position = A[0];
 
    // If a subsequence of size B
    // with min diff = mid is possible
    // return true else false
    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 to find the maximum of
// all minimum difference of pairs
// possible among the subsequence
function find_min_difference(A, n, B)
{
 
    // Sort the Array
    A.sort();
 
    // Stores the boundaries
    // of the search space
    let s = 0;
    let e = A[n - 1] - A[0];
 
    // Store the answer
    let ans = 0;
 
    // Binary Search
    while (s <= e)
    {
        let mid = parseInt((s + e) / 2, 10);
 
        // 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
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);
 
// This code is contributed by divyesh072019
 
</script>


Output: 

2

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

 



Last Updated : 16 Aug, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads