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

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[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

 ``

Output:

`2`

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

Previous
Next