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(2^N*N²)
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)