最小移除数组以使最大值–最小值<= K

给定N个整数和K，找到应删除的最小元素数，以使A _max -A _min <= K。删除元素后，其余元素中将考虑A _max和A _min 。

例子：

Input : a[] = {1, 3, 4, 9, 10, 11, 12, 17, 20} 
          k = 4 
Output : 5 
Explanation: Remove 1, 3, 4 from beginning 
and 17, 20 from the end.

Input : a[] = {1, 5, 6, 2, 8}  K=2
Output : 3
Explanation: There are multiple ways to 
remove elements in this case.
One among them is to remove 5, 6, 8.
The other is to remove 1, 2, 5

方法：对给定的元素进行排序。使用贪婪方法，最好的方法是删除最小元素或最大元素，然后检查A _max -A _min <= K。必须考虑多种清除组合。我们编写一个递归关系以尝试所有可能的组合。有两种可能的删除方式，即我们删除最小值或我们删除最大值。令(i…j)为元素删除后剩余元素的索引。最初，我们从i = 0和j = n-1开始，开始删除的元素数为0。仅当a [j] -a [i]> k时才删除元素，两种可能的删除方式是(i + 1 … j)或(i … j-1) 。考虑两者中的最小值。
设DP _i，j为需要删除的元素数，以便在删除后a [j] -a [i] <= k。

排序数组的递归关系：

DPi, j = 1+ (min(countRemovals(i+1, j), countRemovals(i, j-1))

下面是上述想法的实现：

C++

// CPP program to find minimum removals
// to make max-min <= K
#include 
using namespace std;
 
#define MAX 100
int dp[MAX][MAX];
 
// function to check all possible combinations
// of removal and return the minimum one
int countRemovals(int a[], int i, int j, int k)
{
    // base case when all elements are removed
    if (i >= j)
        return 0;
 
    // if condition is satisfied, no more
    // removals are required
    else if ((a[j] - a[i]) <= k)
        return 0;
 
    // if the state has already been visited
    else if (dp[i][j] != -1)
        return dp[i][j];
 
    // when Amax-Amin>d
    else if ((a[j] - a[i]) > k) {
 
        // minimum is taken of the removal
        // of minimum element or removal
        // of the maximum element
        dp[i][j] = 1 + min(countRemovals(a, i + 1, j, k),
                           countRemovals(a, i, j - 1, k));
    }
    return dp[i][j];
}
 
// To sort the array and return the answer
int removals(int a[], int n, int k)
{
    // sort the array
    sort(a, a + n);
 
    // fill all stated with -1
    // when only one element
    memset(dp, -1, sizeof(dp));
    if (n == 1)
        return 0;
    else
        return countRemovals(a, 0, n - 1, k);
}
 
// Driver Code
int main()
{
    int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };
    int n = sizeof(a) / sizeof(a[0]);
    int k = 4;
    cout << removals(a, n, k);
    return 0;
}

Java

// Java program to find minimum removals
// to make max-min <= K
import java.util.Arrays;
 
class GFG
{
    static int MAX=100;
    static int dp[][]=new int[MAX][MAX];
     
    // function to check all possible combinations
    // of removal and return the minimum one
    static int countRemovals(int a[], int i, int j, int k)
    {
        // base case when all elements are removed
        if (i >= j)
            return 0;
     
        // if condition is satisfied, no more
        // removals are required
        else if ((a[j] - a[i]) <= k)
            return 0;
     
        // if the state has already been visited
        else if (dp[i][j] != -1)
            return dp[i][j];
     
        // when Amax-Amin>d
        else if ((a[j] - a[i]) > k) {
     
            // minimum is taken of the removal
            // of minimum element or removal
            // of the maximum element
            dp[i][j] = 1 + Math.min(countRemovals(a, i + 1, j, k),
                                    countRemovals(a, i, j - 1, k));
        }
        return dp[i][j];
    }
     
    // To sort the array and return the answer
    static int removals(int a[], int n, int k)
    {
        // sort the array
        Arrays.sort(a);
     
        // fill all stated with -1
        // when only one element
        for(int[] rows:dp)
        Arrays.fill(rows,-1);
        if (n == 1)
            return 0;
        else
            return countRemovals(a, 0, n - 1, k);
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };
        int n = a.length;
        int k = 4;
        System.out.print(removals(a, n, k));
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python program to find
# minimum removals to
# make max-min <= K
MAX = 100
dp = [[0 for i in range(MAX)]
         for i in range(MAX)]
for i in range(0, MAX) :
    for j in range(0, MAX) :
        dp[i][j] = -1
 
# function to check all
# possible combinations
# of removal and return
# the minimum one
def countRemovals(a, i, j, k) :
 
    global dp
     
    # base case when all
    # elements are removed
    if (i >= j) :
        return 0
 
    # if condition is satisfied,
    # no more removals are required
    elif ((a[j] - a[i]) <= k) :
        return 0
 
    # if the state has
    # already been visited
    elif (dp[i][j] != -1) :
        return dp[i][j]
 
    # when Amax-Amin>d
    elif ((a[j] - a[i]) > k) :
 
        # minimum is taken of
        # the removal of minimum
        # element or removal of
        # the maximum element
        dp[i][j] = 1 + min(countRemovals(a, i + 1,
                                         j, k),
                           countRemovals(a, i,
                                         j - 1, k))
    return dp[i][j]
 
# To sort the array
# and return the answer
def removals(a, n, k) :
 
    # sort the array
    a.sort()
 
    # fill all stated
    # with -1 when only
    # one element
    if (n == 1) :
        return 0
    else :
        return countRemovals(a, 0,
                             n - 1, k)
 
# Driver Code
a = [1, 3, 4, 9, 10,
     11, 12, 17, 20]
n = len(a)
k = 4
print (removals(a, n, k))
 
# This code is contributed by
# Manish Shaw(manishshaw1)

C#

// C# program to find minimum
// removals to make max-min <= K
using System;
 
class GFG
{
    static int MAX = 100;
    static int [,]dp = new int[MAX, MAX];
     
    // function to check all
    // possible combinations
    // of removal and return
    // the minimum one
    static int countRemovals(int []a, int i,
                             int j, int k)
    {
        // base case when all
        // elements are removed
        if (i >= j)
            return 0;
     
        // if condition is satisfied,
        // no more removals are required
        else if ((a[j] - a[i]) <= k)
            return 0;
     
        // if the state has
        // already been visited
        else if (dp[i, j] != -1)
            return dp[i, j];
     
        // when Amax-Amin>d
        else if ((a[j] - a[i]) > k)
        {
     
            // minimum is taken of the
            // removal of minimum element
            // or removal of the maximum
            // element
            dp[i, j] = 1 + Math.Min(countRemovals(a, i + 1,
                                                  j, k),
                                    countRemovals(a, i,
                                                  j - 1, k));
        }
        return dp[i, j];
    }
     
    // To sort the array and
    // return the answer
    static int removals(int []a,
                        int n, int k)
    {
        // sort the array
        Array.Sort(a);
     
        // fill all stated with -1
        // when only one element
        for(int i = 0; i < MAX; i++)
        {
            for(int j = 0; j < MAX; j++)
                dp[i, j] = -1;
        }
        if (n == 1)
            return 0;
        else
            return countRemovals(a, 0,
                                 n - 1, k);
    }
     
    // Driver code
    static void Main()
    {
        int []a = new int[]{ 1, 3, 4, 9, 10,
                             11, 12, 17, 20 };
        int n = a.Length;
        int k = 4;
        Console.Write(removals(a, n, k));
    }
}
 
// This code is contributed by
// ManishShaw(manishshaw1)

PHP

= $j)
        return 0;
 
    // if condition is satisfied,
    // no more removals are required
    else if (($a[$j] - $a[$i]) <= $k)
        return 0;
 
    // if the state has
    // already been visited
    else if ($dp[$i][$j] != -1)
        return $dp[$i][$j];
 
    // when Amax-Amin>d
    else if (($a[$j] - $a[$i]) > $k)
    {
 
        // minimum is taken of
        // the removal of minimum
        // element or removal of
        // the maximum element
        $dp[$i][$j] = 1 + min(countRemovals($a, $i + 1,
                                                $j, $k),
                              countRemovals($a, $i,
                                            $j - 1, $k));
    }
    return $dp[$i][$j];
}
 
// To sort the array
// and return the answer
function removals($a, $n, $k)
{
    // sort the array
    sort($a);
 
    // fill all stated with -1
    // when only one element
    if ($n == 1)
        return 0;
    else
        return countRemovals($a, 0,
                             $n - 1, $k);
}
 
// Driver Code
$a = array(1, 3, 4, 9, 10,
           11, 12, 17, 20);
$n = count($a);
$k = 4;
echo (removals($a, $n, $k));
 
// This code is contributed by
// Manish Shaw(manishshaw1)
?>

---

输出

5

时间复杂度： O(n ² )
辅助空间： O(n ² )

该解决方案可以进一步优化。想法是按递增顺序对数组进行排序，并遍历所有元素(比方说索引i)，并在其右侧找到最大元素(索引j)，以使arr [j] – arr [i] <= k。因此，要去除的元素数量变为n-(j-i + 1)。元素的最小数量可以通过对所有i取n-(ji-1)中的最小值来找到。索引j的值可通过在start = i + 1和end = n-1之间进行二分查找来找到；

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find
// rightmost index
// which satsfies the condition
// arr[j] - arr[i] <= k
int findInd(int key, int i,
            int n, int k, int arr[])
{
    int start, end, mid, ind = -1;
     
    // Initialising start to i + 1
    start = i + 1;
     
    // Initialising end to n - 1
    end = n - 1;
     
    // Binary search implementation
    // to find the rightmost element
    // that satisfy the condition
    while (start < end)
    {
        mid = start + (end - start) / 2;
         
        // Check if the condition satsfies
        if (arr[mid] - key <= k)
        {  
             
            // Store the position
            ind = mid;
             
            // Make start = mid + 1
            start = mid + 1;
        }
        else
        {
            // Make end = mid
            end = mid;
        }
    }
     
    // Return the rightmost position
    return ind;
}
 
// Function to calculate
// minimum number of elements
// to be removed
int removals(int arr[], int n, int k)
{
    int i, j, ans = n - 1;
     
    // Sort the given array
    sort(arr, arr + n);
     
    // Iterate from 0 to n-1
    for (i = 0; i < n; i++)
    {
         
        // Find j such that
        // arr[j] - arr[i] <= k
        j = findInd(arr[i], i, n, k, arr);
         
        // If there exist such j
        // that satisfies the condition
        if (j != -1)
        {
            // Number of elements
            // to be removed for this
            // particular case is
            // (j - i + 1)
            ans = min(ans, n - (j - i + 1));
        }
    }
     
    // Return answer
    return ans;
}
 
// Driver Code
int main()
{
    int a[] = {1, 3, 4, 9, 10,
               11, 12, 17, 20};
    int n = sizeof(a) / sizeof(a[0]);
    int k = 4;
    cout << removals(a, n, k);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
     
// Function to find rightmost index
// which satsfies the condition
// arr[j] - arr[i] <= k
static int findInd(int key, int i,
                   int n, int k, int arr[])
{
    int start, end, mid, ind = -1;
     
    // Initialising start to i + 1
    start = i + 1;
     
    // Initialising end to n - 1
    end = n - 1;
     
    // Binary search implementation
    // to find the rightmost element
    // that satisfy the condition
    while (start < end)
    {
        mid = start + (end - start) / 2;
         
        // Check if the condition satsfies
        if (arr[mid] - key <= k)
        {
             
            // Store the position
            ind = mid;
             
            // Make start = mid + 1
            start = mid + 1;
        }
        else
        {
             
            // Make end = mid
            end = mid;
        }
    }
     
    // Return the rightmost position
    return ind;
}
 
// Function to calculate
// minimum number of elements
// to be removed
static int removals(int arr[], int n, int k)
{
    int i, j, ans = n - 1;
     
    // Sort the given array
    Arrays.sort(arr);
     
    // Iterate from 0 to n-1
    for(i = 0; i < n; i++)
    {
         
        // Find j such that
        // arr[j] - arr[i] <= k
        j = findInd(arr[i], i, n, k, arr);
         
        // If there exist such j
        // that satisfies the condition
        if (j != -1)
        {
             
            // Number of elements
            // to be removed for this
            // particular case is
            // (j - i + 1)
            ans = Math.min(ans,
                           n - (j - i + 1));
        }
    }
     
    // Return answer
    return ans;
}
 
// Driver Code
public static void main(String args[])
{
    int a[] = { 1, 3, 4, 9, 10,
                11, 12, 17, 20 };
    int n = a.length;
    int k = 4;
     
    System.out.println(removals(a, n, k));
}
}
 
// This code is contributed by adityapande88

Python3

# Python program for the
# above approach
 
# Function to find
# rightmost index
# which satsfies the condition
# arr[j] - arr[i] <= k
def findInd(key, i, n,
            k, arr):
   
     ind = -1
     
     # Initialising start
     # to i + 1
     start = i + 1
       
     # Initialising end
     # to n - 1
     end = n - 1;
     
     # Binary search implementation
     # to find the rightmost element
     # that satisfy the condition
     while (start < end):
          mid = int(start +
                   (end - start) / 2)
         
          # Check if the condition
          # satsfies
          if (arr[mid] - key <= k):
             
               # Store the position
               ind = mid
                 
               # Make start = mid + 1
               start = mid + 1
          else:
               # Make end = mid
               end = mid
                 
     # Return the rightmost position
     return ind
     
# Function to calculate
# minimum number of elements
# to be removed
def removals(arr, n, k):
   
     ans = n - 1
     
     # Sort the given array
     arr.sort()
     
     # Iterate from 0 to n-1
     for i in range(0, n):
       
          # Find j such that
          # arr[j] - arr[i] <= k
          j = findInd(arr[i], i,
                      n, k, arr)
           
          # If there exist such j
          # that satisfies the condition
          if (j != -1):
             
               # Number of elements
               # to be removed for this
               # particular case is
               # (j - i + 1)
               ans = min(ans, n -
                        (j - i + 1))
               
     # Return answer
     return ans
     
# Driver Code
a = [1, 3, 4, 9,
     10,11, 12, 17, 20]
n = len(a)
k = 4
print(removals(a, n, k))
 
# This code is contributed by Stream_Cipher

C＃

// C# program for the above approach
using System;
 
class GFG{
     
// Function to find rightmost index
// which satsfies the condition
// arr[j] - arr[i] <= k
static int findInd(int key, int i,
                   int n, int k, int[] arr)
{
    int start, end, mid, ind = -1;
      
    // Initialising start to i + 1
    start = i + 1;
      
    // Initialising end to n - 1
    end = n - 1;
      
    // Binary search implementation
    // to find the rightmost element
    // that satisfy the condition
    while (start < end)
    {
        mid = start + (end - start) / 2;
          
        // Check if the condition satsfies
        if (arr[mid] - key <= k)
        {
             
            // Store the position
            ind = mid;
              
            // Make start = mid + 1
            start = mid + 1;
        }
        else
        {
             
            // Make end = mid
            end = mid;
        }
    }
     
    // Return the rightmost position
    return ind;
}
  
// Function to calculate minimum
// number of elements to be removed
static int removals(int[] arr, int n, int k)
{
    int i, j, ans = n - 1;
      
    // Sort the given array
    Array.Sort(arr);
      
    // Iterate from 0 to n-1
    for(i = 0; i < n; i++)
    {
          
        // Find j such that
        // arr[j] - arr[i] <= k
        j = findInd(arr[i], i, n, k, arr);
          
        // If there exist such j
        // that satisfies the condition
        if (j != -1)
        {
              
            // Number of elements
            // to be removed for this
            // particular case is
            // (j - i + 1)
            ans = Math.Min(ans,
                           n - (j - i + 1));
        }
    }
      
    // Return answer
    return ans;
}
 
// Driver code
static void Main()
{
    int[] a = { 1, 3, 4, 9, 10,
                11, 12, 17, 20 };
    int n = a.Length;
    int k = 4;
      
    Console.Write(removals(a, n, k));
}
}
 
// This code is contributed by sanjoy_62

输出

5

时间复杂度： O(nlogn)

辅助空间： O(n)

方法：

1. 该解决方案可以进一步优化。想法是按升序对数组进行排序并遍历所有元素(假设索引j)并找到其左侧的最小元素(索引i)，使得arr [j] – arr [i] <= k并存储放在dp [j]中。
2. 因此，要去除的元素数量变为n-(j-i + 1)。元素的最小数量可以通过对所有j取n-(ji-1)中的最小值来找到。索引i的值可以通过其先前的dp数组元素值找到。

下面是该方法的实现：

C++

// C++ program for the above approach
#include
using namespace std;
 
// To sort the array and return the answer
int removals(int arr[], int n, int k)
{
   
  // sort the array
  sort(arr, arr + n);
  int dp[n];
 
  // fill all stated with -1
  // when only one element
  for(int i = 0; i < n; i++)
    dp[i] = -1;
 
  // as dp[0] = 0 (base case) so min
  // no of elements to be removed are
  // n-1 elements
  int ans = n - 1;
  dp[0] = 0;
  for (int i = 1; i < n; i++)
  {
    dp[i] = i;
    int j = dp[i - 1];
    while (j != i && arr[i] - arr[j] > k)
    {
      j++;
    }
    dp[i] = min(dp[i], j);
    ans = min(ans, (n - (i - j + 1)));
  }
  return ans;
}
 
// Driver code   
int main()
{
  int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };
  int n = sizeof(a) / sizeof(a[0]);
  int k = 4;
  cout<

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
   
    // To sort the array and return the answer
    static int removals(int arr[], int n, int k)
    {
        // sort the array
        Arrays.sort(arr);
 
        // fill all stated with -1
        // when only one element
        int dp[] = new int[n];
        Arrays.fill(dp, -1);
       
        // as dp[0] = 0 (base case) so min
        // no of elements to be removed are
        // n-1 elements
        int ans = n - 1;
        dp[0] = 0;
       
        // Iterate from 1 to n - 1
        for (int i = 1; i < n; i++) {
            dp[i] = i;
            int j = dp[i - 1];
            while (j != i && arr[i] - arr[j] > k) {
                j++;
            }
            dp[i] = Integer.min(dp[i], j);
            ans = Integer.min(ans, (n - (i - j + 1)));
        }
        return ans;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a[] = { 1, 3, 4, 9, 10, 11, 12, 17, 20 };
        int n = a.length;
        int k = 4;
        System.out.print(removals(a, n, k));
    }
}

Python3

# Python3 program for the above approach
 
# To sort the array and return the answer
def removals(arr, n, k):
     
  # sort the array
  arr.sort()
  dp = [0 for i in range(n)]
 
  # Fill all stated with -1
  # when only one element
  for i in range(n):
    dp[i] = -1
 
  # As dp[0] = 0 (base case) so min
  # no of elements to be removed are
  # n-1 elements
  ans = n - 1
  dp[0] = 0
   
  for i in range(1, n):
    dp[i] = i
    j = dp[i - 1]
     
    while (j != i and arr[i] - arr[j] > k):
      j += 1
       
    dp[i] = min(dp[i], j)
    ans = min(ans, (n - (i - j + 1)))
     
  return ans
 
# Driver code   
a = [ 1, 3, 4, 9, 10, 11, 12, 17, 20 ]
n = len(a)
k = 4
 
print(removals(a, n, k))
 
# This code is contributed by rohan07

输出

5

时间复杂度：O(n)。由于外部循环将进行n次交互。对于所有外部迭代，内部循环最多重复n次。因为我们从dp [i-1]开始j的值并循环直到它到达i，然后对于下一个元素，我们再次从先前的dp [i]值开始。因此，如果我们不考虑排序的复杂性，则总时间复杂度为O(n)，因为上述解决方案中也未考虑排序的复杂性。

辅助空间：O(n)