删除 k 个元素后的最大不同元素

给定一个包含n 个元素的数组arr[] 。问题是在从数组中删除k 个元素后找到最大数量的不同元素（非重复）。
注意： 1 <= k <= n。
例子：

Input : arr[] = {5, 7, 5, 5, 1, 2, 2}, k = 3
Output : 4
Remove 2 occurrences of element 5 and
1 occurrence of element 2.

Input : arr[] = {1, 2, 3, 4, 5, 6, 7}, k = 5
Output : 2

Input : arr[] = {1, 2, 2, 2}, k = 1
Output : 1

方法：以下是步骤：

1. 从给定的数组中创建一个多集。

2. 在做这个 multiset 的过程中，检查当前元素是否存在于 multiset 中，如果它已经存在，那么只需减少 k 值并且不要插入到 multiset 中。

3. 如果 k 变为 0，那么只需将值放入多重集中。

4.遍历整个给定数组后，

a) 如果 k 不等于 0，则表示多重集仅由唯一元素组成，我们必须从多重集中删除 k 个元素中的任何一个以使 k=0，因此在这种情况下，答案将是多重集的大小减去当时的k值。

b) 如果 k 等于 0，则表示多集中可能存在重复值，因此将所有值放在一个集合中，该集合的大小将是删除 k 个元素后不同元素的数量

C++

// CPP implementation of the above approach
#include 
using namespace std;
   
// function to find maximum distinct elements
// after removing k elements
int maxDistinctNum(int a[], int n, int k)
{
  int i;
  multiset s;
  // making multiset from given array
        for(i=0;i st;
            for(auto it:s){
                st.insert(it);
            }
            return st.size();
        }
}
 
// Driver Code
int main()
{
    int arr[] = { 5, 7, 5, 5, 1, 2, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
   
    // Function Call
    cout << "Maximum distinct elements = "
         << maxDistinctNum(arr, n, k);
    return 0;
}

Java

// Java implementation of the
// above approach
import java.util.*;
class GFG{
     
// Function to find maximum
// distinct elements after
// removing k elements
static int maxDistinctNum(int arr[],
                          int n, int k)
{
  HashMap numToFreq = new HashMap<>();
 
  // Build frequency map
  for(int i = 0 ; i < n ; i++)
  {
    numToFreq.put(arr[i],
    numToFreq.getOrDefault(arr[i], 0) + 1);
  }
 
  int result = 0;
 
  // Min-heap
  PriorityQueue minHeap =
                new PriorityQueue();
 
  // Add all number with freq=1 to
  // result and push others to minHeap
  for(Map.Entry p : numToFreq.entrySet())
  {
    if(p.getValue() == 1)
      ++result;
    else
      minHeap.add(p.getValue());
  }
 
  // Perform k operations
  while(k != 0 && !minHeap.isEmpty())
  {
    // Pop the top() element
    Integer t = minHeap.poll();
     
    // Increment Result
    if(t == 1)
    {
      ++result;
    }
 
    // Reduce t and k
    // Push it again
    else
    {
      --t;
      --k;
      minHeap.add(t);
    }
  }
 
  // Return result
  return result;
}
 
// Driver code
public static void main(String[] args)
{       
  int arr[] = {5, 7, 5, 5, 1, 2, 2};
  int n = arr.length;
  int k = 3;
 
  // Function Call
  System.out.println("Maximum distinct elements = " + 
                      maxDistinctNum(arr, n, k));
}
}
 
// This code is contributed by rutvik_56

Javascript

 
// Javascript implementation of the above approach
   
// function to find maximum distinct elements
// after removing k elements
function maxDistinctNum(a, n, k)
{
  var i;
  var s = [];
  // making multiset from given array
        for(i=0;i<n;i++){
            if(!s.includes(a[i])||k==0)
            s.push(a[i]);
            else
            {
                k--;
            }
        }
   
        if(k!=0)
            return s.size-k;
        else{
            var st = new Set();
            s.forEach(element => {
                st.add(element);
            });
             
            return st.size;
        }
}
 
// Driver Code
var arr = [5, 7, 5, 5, 1, 2, 2];
var n = arr.length;
var k = 3;
 
// Function Call
document.write( "Maximum distinct elements = "
      +  maxDistinctNum(arr, n, k));
 
// This code is contributed by itsok.

输出：

Maximum distinct elements = 4

时间复杂度： O(k*logd)，其中d是给定数组中不同元素的数量。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。