Maximum Size of a Set After Removals - Problem

You are given two 0-indexed integer arrays nums1 and nums2 of even length n.

You must remove n / 2 elements from nums1 and n / 2 elements from nums2. After the removals, you insert the remaining elements of nums1 and nums2 into a set s.

Return the maximum possible size of the set s.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Remove [3,4] from nums1 and [3,4] from nums2. Remaining: [1,2] and [5,6]. Final set: {1,2,5,6} has size 4.

Example 2 — All Common Elements

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

› Output: 2

💡 Note: Remove duplicates optimally. Keep [1,2] from nums1 and [1] from nums2. Final set: {1,2} has size 2.

Example 3 — No Common Elements

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

› Output: 4

💡 Note: No overlap between arrays. Keep [1,2] from nums1 and [3,4] from nums2. Final set: {1,2,3,4} has size 4.

Constraints

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

Visualization

Tap to expand

Asked in

M Meta 35 G Google 28 a Amazon 22

The key insight is to categorize elements into three groups: only in nums1, only in nums2, and common to both. The optimal strategy is to greedily keep unique elements first, then handle common elements to minimize overlap. Best approach is the Optimal Greedy Strategy with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(n,n/2)²) Space: O(n)

For each array, try every combination of removing n/2 elements, then combine remaining elements into a set and count unique values. This explores all possibilities but is extremely slow.

Frequency Count with Greedy Selection

⏱️ Time: O(n) Space: O(n)

First count how many times each element appears in each array and between arrays. Then use greedy strategy: prioritize unique elements within each array, and handle overlapping elements optimally.

Optimal Greedy Strategy

⏱️ Time: O(n) Space: O(n)

The key insight is that we want to maximize unique elements in the final set. We analyze three categories: elements only in nums1, only in nums2, and in both arrays. Then apply greedy selection to minimize overlap.

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 combination pair, create set from remaining elements
Return maximum set size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

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

Test Each Pair

For each combination pair, merge remaining elements

Find Maximum

Track the largest set size across all combinations

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

void getCombinations(int n, int k, int start, int* current, int currentSize, int** result, int* resultSize, int* resultCount) {
    if (currentSize == k) {
        result[*resultCount] = (int*)malloc(k * sizeof(int));
        for (int i = 0; i < k; i++) {
            result[*resultCount][i] = current[i];
        }
        (*resultCount)++;
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = i;
        getCombinations(n, k, i + 1, current, currentSize + 1, result, resultSize, resultCount);
    }
}

int binomial(int n, int k) {
    if (k > n) return 0;
    if (k == 0 || k == n) return 1;
    
    int result = 1;
    for (int i = 0; i < k; i++) {
        result = result * (n - i) / (i + 1);
    }
    return result;
}

int solution(int* nums1, int* nums2, int n) {
    int half = n / 2;
    int max_size = 0;
    
    int maxCombinations = binomial(n, half);
    int** combinations1 = (int**)malloc(maxCombinations * sizeof(int*));
    int** combinations2 = (int**)malloc(maxCombinations * sizeof(int*));
    int count1 = 0, count2 = 0;
    
    int* current = (int*)malloc(half * sizeof(int));
    
    getCombinations(n, half, 0, current, 0, combinations1, &maxCombinations, &count1);
    getCombinations(n, half, 0, current, 0, combinations2, &maxCombinations, &count2);
    
    for (int i = 0; i < count1; i++) {
        for (int j = 0; j < count2; j++) {
            int removeSet1[100] = {0};
            int removeSet2[100] = {0};
            
            for (int k = 0; k < half; k++) {
                removeSet1[combinations1[i][k]] = 1;
                removeSet2[combinations2[j][k]] = 1;
            }
            
            int keep1[100], keep2[100];
            int keep1Size = 0, keep2Size = 0;
            
            for (int k = 0; k < n; k++) {
                if (!removeSet1[k]) {
                    keep1[keep1Size++] = nums1[k];
                }
                if (!removeSet2[k]) {
                    keep2[keep2Size++] = nums2[k];
                }
            }
            
            int used[2001] = {0};
            int uniqueCount = 0;
            
            for (int k = 0; k < keep1Size; k++) {
                if (!used[keep1[k] + 1000]) {
                    used[keep1[k] + 1000] = 1;
                    uniqueCount++;
                }
            }
            for (int k = 0; k < keep2Size; k++) {
                if (!used[keep2[k] + 1000]) {
                    used[keep2[k] + 1000] = 1;
                    uniqueCount++;
                }
            }
            
            max_size = max(max_size, uniqueCount);
        }
    }
    
    for (int i = 0; i < count1; i++) {
        free(combinations1[i]);
    }
    for (int i = 0; i < count2; i++) {
        free(combinations2[i]);
    }
    free(combinations1);
    free(combinations2);
    free(current);
    
    return max_size;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums1[100], nums2[100];
    int n = 0;
    
    char* token = strtok(line1, "[],\n ");
    while (token != NULL && n < 100) {
        nums1[n] = atoi(token);
        token = strtok(NULL, "[],\n ");
        n++;
    }
    
    int idx = 0;
    token = strtok(line2, "[],\n ");
    while (token != NULL && idx < n) {
        nums2[idx] = atoi(token);
        token = strtok(NULL, "[],\n ");
        idx++;
    }
    
    printf("%d\n", solution(nums1, nums2, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

Generate C(n,n/2) combinations for each array, where C(n,n/2) can be exponentially large

✓ Linear Growth

Space Complexity

O(n)

Store combinations and temporary sets

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Maximum Size of a Set After Removals - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler