Subsets II

Subsets II - Problem

Given an integer array nums that may contain duplicates, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

Note: A subset is a selection of elements from the array, including the empty subset and the array itself.

Input & Output

Example 1 — Basic Case with Duplicates

$ Input: nums = [1,2,2]

› Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]

💡 Note: The array contains duplicates. All unique subsets are: empty set, single elements [1] and [2], pairs [1,2] and [2,2], and the full array [1,2,2]. Note that [2] appears only once even though there are two 2s.

Example 2 — All Identical Elements

$ Input: nums = [4,4,4]

› Output: [[],[4],[4,4],[4,4,4]]

💡 Note: When all elements are identical, we get subsets of different lengths: empty, single element, pair, and triplet. No actual duplicates in the result.

Example 3 — No Duplicates

$ Input: nums = [1,2,3]

› Output: [[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]

💡 Note: When there are no duplicates in input, this behaves like the regular Subsets problem, generating all 2^3 = 8 possible subsets.

Constraints

1 ≤ nums.length ≤ 10
-10 ≤ nums[i] ≤ 10

Visualization

Tap to expand

Asked in

F Facebook 35 a Amazon 28 M Microsoft 22 G Google 18

The key insight is to sort the array first, then use backtracking while skipping duplicate elements at the same recursion level. Best approach is backtracking with duplicate skipping. Time: O(n × 2^n), Space: O(n × 2^n)

Common Approaches

✓ Backtracking with Duplicate Skipping

⏱️ Time: O(n × 2^n) Space: O(n × 2^n)

Sort the input array to group duplicates together. Use recursive backtracking to build subsets, but skip duplicate elements when they appear at the same recursion level to avoid duplicate subsets.

Bit Manipulation with Sorted Deduplication

⏱️ Time: O(n × 2^n) Space: O(1)

Sort the array to group duplicates. Use bit manipulation to generate all subsets, but implement smart skipping: when we encounter a duplicate element, only include it if all previous identical elements are also included.

Generate All + Remove Duplicates

⏱️ Time: O(n × 2^n) Space: O(n × 2^n)

Use bit manipulation to generate all possible subsets, convert each to a sorted string for deduplication, then remove duplicates using a set data structure.

Backtracking with Duplicate Skipping — Algorithm Steps

Sort the input array to group duplicates
Use recursive backtracking to build subsets
Skip duplicate elements at the same recursion level

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort First

Sort array to group duplicate elements together

Backtrack

Recursively build subsets while skipping same-level duplicates

Unique Result

Generate only unique subsets directly

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

void backtrack(int* nums, int numsSize, int start, int* current, int currentSize, 
               int** result, int* returnColumnSizes, int* resultSize) {
    // Add current subset to result
    result[*resultSize] = (int*)malloc(currentSize * sizeof(int));
    for (int i = 0; i < currentSize; i++) {
        result[*resultSize][i] = current[i];
    }
    returnColumnSizes[*resultSize] = currentSize;
    (*resultSize)++;
    
    for (int i = start; i < numsSize; i++) {
        // Skip duplicates at the same level
        if (i > start && nums[i] == nums[i - 1]) {
            continue;
        }
        
        current[currentSize] = nums[i];
        backtrack(nums, numsSize, i + 1, current, currentSize + 1, result, returnColumnSizes, resultSize);
    }
}

int** solution(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    int maxSubsets = 1 << numsSize;
    int** result = (int**)malloc(maxSubsets * sizeof(int*));
    *returnColumnSizes = (int*)malloc(maxSubsets * sizeof(int));
    int* current = (int*)malloc(numsSize * sizeof(int));
    *returnSize = 0;
    
    backtrack(nums, numsSize, 0, current, 0, result, *returnColumnSizes, returnSize);
    
    free(current);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    // Simple input parsing
    int nums[10];
    int numsSize = 0;
    
    // Read array - simplified parsing
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[,]");
    while (token != NULL && numsSize < 10) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(nums, numsSize, &returnSize, &returnColumnSizes);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

Each subset takes O(n) time to copy, and there are 2^n unique subsets

⚠ Quadratic Growth

Space Complexity

O(n × 2^n)

Recursion depth O(n) plus space to store all 2^n subsets

⚠ Quadratic Space

185.0K Views

Medium Frequency

~15 min Avg. Time

3.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

Backtracking with Duplicate Skipping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler