给定大小的子序列中所有对的最小差的最大值

给定大小为N的整数数组A [] ，任务是找到大小为B的子序列，以使它们中的任意两个之间的最小差异最大，并打印出该最大最小差异。

例子：

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.

天真的方法：
解决此问题的最简单方法是生成大小为B的所有可能子序列，并在所有可能的对之间找到最小差异。最后，在所有最小差异中找到最大值。

时间复杂度： O(2 ^N * N ² )
辅助空间： O(N)

高效方法：
请按照以下步骤使用Binary Search优化上述方法：

• 将搜索空间从0设置为array( maxm )中的最大元素
• 对于每一个计算出的中间，检查是否有可能获得大小B的子序列与任何一对之间的最小差值等于中旬。
• 如果可能的话，然后存储在中期的变量，并找到在右半更好的答案，并丢弃中间的左半
• 否则，遍历中部的左半部分，以检查是否存在具有最小成对最小差异的子序列。
• 最后，在二分查找终止后，打印出最高的中位数，在该最高中位数中发现任何具有等于中位数对的最小差的子序列。

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.

下面是上述方法的实现：

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

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

输出：

2

时间复杂度： O(NlogN)
辅助空间： O(1)