Maximum Size of a Set After Removals - Practice Coding Problems

Maximum Size of a Set After Removals - Problem

Maximum Size of a Set After Removals

You're given two integer arrays nums1 and nums2, each of even length n. Your goal is to strategically remove exactly n/2 elements from each array, then combine all remaining elements into a single set.

The challenge: What's the maximum possible size of the final set?

Since we're dealing with a set, duplicate elements are automatically removed. Your task is to decide which elements to keep from each array to maximize the number of unique elements in the final result.

Example: If nums1 = [1,2,3,4] and nums2 = [3,4,5,6], you need to keep 2 elements from each array. The optimal strategy might be to keep [1,2] from nums1 and [5,6] from nums2, resulting in a set of size 4.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,2,3,4], nums2 = [3,4,5,6]

› Output: 4

💡 Note: Remove elements {3,4} from nums1 and {3,4} from nums2. The remaining elements are {1,2} from nums1 and {5,6} from nums2. The final set is {1,2,5,6} with size 4.

example_2.py — All Common Elements

$ Input: nums1 = [1,2,1,2], nums2 = [1,1,2,2]

› Output: 2

💡 Note: Both arrays contain the same unique elements {1,2}. After removing n/2=2 elements from each array, we can keep at most 2 unique elements total, giving us the set {1,2}.

example_3.py — No Common Elements

$ Input: nums1 = [1,1,3,3], nums2 = [2,2,4,4]

› Output: 4

💡 Note: Arrays have no common elements. We can keep all unique elements from both arrays: {1,3} from nums1 and {2,4} from nums2, resulting in set {1,2,3,4} with size 4.

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 10⁵
n is even
1 ≤ nums1[i], nums2[i] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Catalog the Collections

Identify which books are unique to each collection and which books appear in both collections

Apply Selection Strategy

Keep all unique books first (they don't create duplicates), then use remaining space for books that appear in both collections

Optimize Final Shelf

The greedy approach ensures maximum variety: prioritize uniqueness, avoid unnecessary duplicates

Key Takeaway

🎯 Key Insight: Just like a librarian prioritizes unique books to maximize variety, our algorithm greedily selects unique elements first, then optimally uses remaining capacity for common elements. This simple strategy guarantees the maximum possible set size!

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal solution uses a greedy hash set approach that categorizes elements into three groups: unique to nums1, unique to nums2, and common to both arrays. By prioritizing unique elements and optimally handling common elements, we achieve O(n) time complexity with a simple and intuitive strategy that maximizes the final set size.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n, n/2)²)	O(n)	Generate all possible ways to remove n/2 elements from each array and find maximum set size
Greedy Hash Set Approach (Optimal)	O(n)	O(n)	Use greedy strategy with hash sets to optimally distribute elements and maximize unique count

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of n/2 elements to remove from nums1
Generate all combinations of n/2 elements to remove from nums2
For each pair of removal combinations, create the remaining elements
Combine remaining elements into a set and measure size
Track and return the maximum set size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to remove n/2 elements from each array

Test Each Pair

For each combination pair, create the resulting set

Track Maximum

Keep track of the largest set size encountered

Code -

solution.c — C

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

int popCount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int maximumSetSize(int* nums1, int* nums2, int n) {
    int maxSize = 0;
    
    for (int mask1 = 0; mask1 < (1 << n); mask1++) {
        if (popCount(mask1) != n / 2) continue;
        
        for (int mask2 = 0; mask2 < (1 << n); mask2++) {
            if (popCount(mask2) != n / 2) continue;
            
            int seen[100001] = {0}; // Assuming elements are within this range
            int count = 0;
            
            // Add remaining elements from nums1
            for (int i = 0; i < n; i++) {
                if ((mask1 & (1 << i)) == 0 && !seen[nums1[i] + 50000]) {
                    seen[nums1[i] + 50000] = 1;
                    count++;
                }
            }
            
            // Add remaining elements from nums2
            for (int i = 0; i < n; i++) {
                if ((mask2 & (1 << i)) == 0 && !seen[nums2[i] + 50000]) {
                    seen[nums2[i] + 50000] = 1;
                    count++;
                }
            }
            
            if (count > maxSize) {
                maxSize = count;
            }
        }
    }
    
    return maxSize;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int* nums1 = (int*)malloc(n * sizeof(int));
    int* nums2 = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums1[i]);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums2[i]);
    }
    
    printf("%d\n", maximumSetSize(nums1, nums2, n));
    
    free(nums1);
    free(nums2);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n, n/2)²)

We generate C(n, n/2) combinations for each array, resulting in exponential time complexity

✓ Linear Growth

Space Complexity

O(n)

Space for storing current combination and the resulting set

⚡ Linearithmic Space

42.8K Views

Medium-High Frequency

~18 min Avg. Time

1.3K 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler