Least Number of Unique Integers after K Removals

Least Number of Unique Integers after K Removals - Problem

You're given an array of integers arr and an integer k. Your goal is to minimize the number of unique integers in the array by removing exactly k elements.

Think of it as a strategic elimination game: you have k removal operations, and you want to use them wisely to reduce the variety of numbers as much as possible. The key insight is that removing all occurrences of a number reduces the unique count by 1, while removing some (but not all) occurrences doesn't change the unique count at all.

For example, if you have [4,3,1,1,3,3,2] and can remove k=3 elements, you could remove one occurrence each of 4, 1, and 2, leaving [3,1,3,3] with 2 unique integers. But a better strategy would be to completely eliminate 4 and 2 (2 removals) and one occurrence of 1 (1 removal), leaving [3,1,3,3] with still 2 unique integers, or even better - remove 4, 2, and both 1's to get [3,3,3] with just 1 unique integer.

Input & Output

example_1.py — Basic Case

$ Input: arr = [5,5,4], k = 1

› Output: 1

💡 Note: Remove the single occurrence of 4. The remaining array is [5,5] which has 1 unique integer (5).

example_2.py — Multiple Strategy

$ Input: arr = [4,3,1,1,3,3,2], k = 3

› Output: 2

💡 Note: Remove 4 (1 removal), remove 2 (1 removal), remove one 1 (1 removal). The remaining array is [3,1,3,3] with 2 unique integers. This is optimal.

example_3.py — Remove All Elements

$ Input: arr = [1], k = 1

› Output: 0

💡 Note: Remove the only element. The remaining array is empty, so there are 0 unique integers.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
0 ≤ k ≤ arr.length
k is always valid (you can always remove exactly k elements)

Visualization

Tap to expand

Understanding the Visualization

Count Your Collection

Count how many songs each artist has (frequency counting)

Prioritize by Rarity

Sort artists by number of songs, rarest first

Strategic Removal

Remove entire discographies of rare artists until you can't remove a complete one

Key Takeaway

🎯 Key Insight: The greedy approach of eliminating complete rare groups before touching common ones is mathematically optimal - partial removals never reduce the unique count, so we should always prioritize complete eliminations.

Asked in

G Google 42 a Amazon 38 f Meta 31 Apple 25

The optimal approach uses frequency counting combined with a greedy strategy. First, count how often each number appears, then sort these frequencies and greedily remove complete groups starting with the rarest numbers. This ensures we eliminate as many unique integers as possible with our k removals. Time complexity: O(n log n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Count + Greedy Removal	O(n log n)	O(n)	Count frequencies first, then greedily remove elements starting with lowest frequencies
Brute Force (Try All Combinations)	O(C(n,k) × n)	O(n)	Generate all possible ways to remove k elements and find the minimum unique count

Frequency Count + Greedy Removal — Algorithm Steps

Count frequency of each unique integer using a hash map
Extract frequency values and sort them in ascending order
Greedily remove complete frequency groups starting from smallest
Count how many complete groups we can remove with k operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency map: {4:1, 3:3, 1:2, 2:1}

Sort Frequencies

Sort frequencies: [1, 1, 2, 3] (from 4, 2, 1, 3)

Greedy Removal

Remove complete groups: 1+1+2 = 4 > k=3, so remove first two

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct FreqNode {
    int value;
    int freq;
};

int compare(const void *a, const void *b) {
    return ((struct FreqNode*)a)->freq - ((struct FreqNode*)b)->freq;
}

int findLeastNumOfUniqueInts(int* arr, int n, int k) {
    // Step 1: Count frequencies (simplified for small numbers)
    struct FreqNode freqs[1000];
    int uniqueCount = 0;
    
    for (int i = 0; i < n; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (freqs[j].value == arr[i]) {
                freqs[j].freq++;
                found = 1;
                break;
            }
        }
        if (!found) {
            freqs[uniqueCount].value = arr[i];
            freqs[uniqueCount].freq = 1;
            uniqueCount++;
        }
    }
    
    // Step 2: Sort by frequency
    qsort(freqs, uniqueCount, sizeof(struct FreqNode), compare);
    
    // Step 3: Greedily remove complete groups
    int removed = 0;
    int result = uniqueCount;
    
    for (int i = 0; i < uniqueCount; i++) {
        if (removed + freqs[i].freq <= k) {
            removed += freqs[i].freq;
            result--;
        } else {
            break;
        }
    }
    
    return result;
}

int main() {
    int arr[] = {4, 3, 1, 1, 3, 3, 2};
    int n = 7, k = 3;
    printf("%d\n", findLeastNumOfUniqueInts(arr, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for counting frequencies + O(n log n) for sorting frequencies

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores at most n unique elements and their frequencies

⚡ Linearithmic Space

67.2K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Frequency Count + Greedy Removal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler