# 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:
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 teminates.
• 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`

Output:

```2
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.