📌  相关文章
📜  给定大小的子序列中所有对的最小差的最大值

📅  最后修改于: 2021-05-13 23:23:18             🧑  作者: Mango

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

例子:

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

时间复杂度: O(2 N * N 2 )
辅助空间: O(N)

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

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

下面是上述方法的实现:

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


输出:
2

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