从数组中删除最小元素，以使2 * min大于max

给定大小为N的数组。任务是从数组中删除最少的元素，以使最小数的两倍大于修改后的数组中的最大数。打印删除的最小元素数。

例子：

Input: arr[] = {4, 5, 100, 9, 10, 11, 12, 15, 200}
Output: 4
Remove 4 elements (4, 5, 100, 200)
so that 2*min becomes more than max.

Input: arr[] = {4, 7, 5, 6}
Output: 0

方法：

• 给定数组排序
• 在数组中从左到右遍历，并为每个选择的元素(索引为x)(索引为i)找到(2 * x)的upper_bound。让该索引为j。然后，如果(n-j + i)小于我们答案的当前值，则通过(n-j + i)更新我们所需的答案。

下面是上述方法的实现：

C++

// CPP program to remove minimum elements from the
// array such that 2*min becomes more than max
#include 
using namespace std;
  
// Function to remove minimum elements from the
// array such that 2*min becomes more than max
int Removal(vector v, int n)
{
    // Sort the array
    sort(v.begin(), v.end());
  
    // To store the required answer
    int ans = INT_MAX;
  
    // Traverse from left to right
    for (vector::iterator i = v.begin(); i != v.end(); 
                                                     i++) {
  
        vector::iterator j = upper_bound(v.begin(), 
                                    v.end(), (2 * (*i)));
  
        // Update the answer
        ans = min(ans, n - (int)(j - i));
    }
  
    // Return the required answer
    return ans;
}
  
// Driver code
int main()
{
    vector a = { 4, 5, 100, 9, 10, 11, 12, 15, 200 };
  
    int n = a.size();
  
    // Function call
    cout << Removal(a, n);
  
    return 0;
}

Java

// Java program to remove minimum elements from the 
// array such that 2*min becomes more than max
import java.util.Arrays;
  
class GFG 
{
  
    // Function to calculate upper bound
    public static int upperBound(int[] array,
                                 int value)
    {
        int low = 0;
        int high = array.length;
        while (low < high) 
        {
            final int mid = (low + high) / 2;
            if (value >= array[mid]) 
            {
                low = mid + 1;
            } 
            else 
            {
                high = mid;
            }
        }
        return low;
    }
  
    // Function to remove minimum elements from the
    // array such that 2*min becomes more than max
    public static int Removal(int[] v, int n) 
    {
  
        // Sort the array
        Arrays.sort(v);
  
        // To store the required answer
        int ans = Integer.MAX_VALUE;
        int k = 0;
  
        // Traverse from left to right
        for (int i : v) 
        {
            int j = upperBound(v, (2 * i));
  
            // Update the answer
            ans = Math.min(ans, n - (j - k));
            k++;
        }
  
        // Return the required answer
        return ans;
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        int[] a = { 4, 5, 100, 9, 10, 
                    11, 12, 15, 200 };
        int n = a.length;
  
        // Function call
        System.out.println(Removal(a, n));
    }
}
  
// This code is contributed by
// sanjeev2552

Python3

# Python3 program to remove minimum elements from the
# array such that 2*min becomes more than max
from bisect import bisect_left as upper_bound
  
# Function to remove minimum elements from the
# array such that 2*min becomes more than max
def Removal(v, n):
      
    # Sort the array
    v = sorted(v)
  
    # To store the required answer
    ans = 10**9
  
    # Traverse from left to right
    for i in range(len(v)):
        j = upper_bound(v, (2 * (a[i])))
  
        # Update the answer
        ans = min(ans, n - (j - i - 1))
  
    # Return the required answer
    return ans
  
# Driver code
a = [4, 5, 100, 9, 10, 11, 12, 15, 200]
  
n = len(a)
  
# Function call
print(Removal(a, n))
  
# This code is contributed by Mohit Kumar

C#

// C# program to remove minimum elements 
// from the array such that 2*min becomes
// more than max
using System;
  
class GFG 
{
  
    // Function to calculate upper bound
    public static int upperBound(int[] array,
                                 int value)
    {
        int low = 0;
        int high = array.Length;
        while (low < high) 
        {
            int mid = (low + high) / 2;
            if (value >= array[mid]) 
            {
                low = mid + 1;
            } 
            else
            {
                high = mid;
            }
        }
        return low;
    }
  
    // Function to remove minimum elements from the
    // array such that 2*min becomes more than max
    public static int Removal(int[] v, int n) 
    {
  
        // Sort the array
        Array.Sort(v);
  
        // To store the required answer
        int ans = int.MaxValue;
        int k = 0;
  
        // Traverse from left to right
        foreach (int i in v) 
        {
            int j = upperBound(v, (2 * i));
  
            // Update the answer
            ans = Math.Min(ans, n - (j - k));
            k++;
        }
  
        // Return the required answer
        return ans;
    }
  
    // Driver code
    public static void Main(String[] args) 
    {
        int[] a = { 4, 5, 100, 9, 10, 
                    11, 12, 15, 200 };
        int n = a.Length;
  
        // Function call
        Console.WriteLine(Removal(a, n));
    }
}
  
// This code is contributed by Rajput-Ji

输出 ：

4

时间复杂度： O(NlogN)