 Open in App
Not now

# 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[``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;`` ` `    ``// 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