Permutations II

Permutations II - Problem

Given a collection of numbers nums that might contain duplicates, return all possible unique permutations in any order.

A permutation is a rearrangement of elements where order matters. Since the input may contain duplicate numbers, we need to ensure that our result contains only unique permutations (no duplicate permutations in the output).

Key Challenge: Handle duplicate elements properly to avoid generating duplicate permutations.

Input & Output

Example 1 — With Duplicates

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

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

💡 Note: The input has duplicate 1s. All unique permutations are: [1,1,2], [1,2,1], and [2,1,1]. Note that [1,1,2] appears only once in output despite having two 1s.

Example 2 — All Duplicates

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

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

💡 Note: Three 1s and one 2. The unique permutations arrange the three 1s in different positions with the single 2.

Example 3 — No Duplicates

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

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

💡 Note: No duplicate elements, so we get all 3! = 6 possible permutations of the three distinct numbers.

Constraints

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

Visualization

Tap to expand

Asked in

M Microsoft 35 a Amazon 28 G Google 25 A Apple 22

The key insight is to sort the input array first, then use backtracking while skipping duplicate elements at the same recursion level. This prevents generating duplicate permutations. Best approach is optimized backtracking. Time: O(n! × n), Space: O(n)

Common Approaches

✓ Brute Force with Set Deduplication

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

Generate every possible permutation using backtracking without any duplicate handling, then convert result to set to remove duplicates. This works but is inefficient since we generate many duplicate permutations only to discard them later.

Optimized Backtracking with Pruning

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

Sort the input array first, then use backtracking while skipping duplicate elements at the same recursion level. This prevents generating duplicate permutations in the first place, making it much more efficient than the brute force approach.

Brute Force with Set Deduplication — Algorithm Steps

Generate all possible permutations recursively
Use set to automatically remove duplicate permutations
Convert back to list format

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create every possible permutation

Use Set

Remove duplicates using set

Result

Unique permutations only

Code -

solution.c — C

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

#define MAX_SIZE 8
#define MAX_RESULTS 40320

int results[MAX_RESULTS][MAX_SIZE];
int resultSizes[MAX_RESULTS];
int resultCount = 0;

int isDuplicate(int* perm, int size) {
    for (int i = 0; i < resultCount; i++) {
        if (resultSizes[i] == size) {
            int match = 1;
            for (int j = 0; j < size; j++) {
                if (results[i][j] != perm[j]) {
                    match = 0;
                    break;
                }
            }
            if (match) return 1;
        }
    }
    return 0;
}

void backtrack(int* path, int pathSize, int* remaining, int remainingSize, int* nums, int numsSize) {
    if (remainingSize == 0) {
        if (!isDuplicate(path, pathSize)) {
            for (int i = 0; i < pathSize; i++) {
                results[resultCount][i] = path[i];
            }
            resultSizes[resultCount] = pathSize;
            resultCount++;
        }
        return;
    }
    
    for (int i = 0; i < remainingSize; i++) {
        path[pathSize] = remaining[i];
        int newRemaining[MAX_SIZE];
        int newSize = 0;
        for (int j = 0; j < remainingSize; j++) {
            if (j != i) {
                newRemaining[newSize++] = remaining[j];
            }
        }
        backtrack(path, pathSize + 1, newRemaining, newSize, nums, numsSize);
    }
}

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() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_SIZE];
    int size = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL && size < MAX_SIZE) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int path[MAX_SIZE];
    backtrack(path, 0, nums, size, nums, size);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("[");
        for (int j = 0; j < resultSizes[i]; j++) {
            printf("%d", results[i][j]);
            if (j < resultSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to create

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Store all permutations including duplicates, each permutation has n elements

⚡ Linearithmic Space

216.0K Views

Medium Frequency

~25 min Avg. Time

7.2K 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 with Set Deduplication — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler