Permutations

Permutations - Problem

Array Backtracking Medium

Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.

A permutation is a rearrangement of all elements in the array where each element appears exactly once in a different order.

Input & Output

Example 1 — Basic Three Elements

$ 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: All 6 possible arrangements of [1,2,3]: start with each element, then arrange the remaining two elements in all possible ways

Example 2 — Two Elements

$ Input: nums = [0,1]

› Output: [[0,1],[1,0]]

💡 Note: Only 2 possible arrangements: [0,1] and [1,0]. With 2 elements, we have 2! = 2 permutations

Example 3 — Single Element

$ Input: nums = [1]

› Output: [[1]]

💡 Note: With only one element, there's only one possible arrangement: [1]. 1! = 1 permutation

Constraints

1 ≤ nums.length ≤ 6
-10 ≤ nums[i] ≤ 10
All the integers of nums are unique

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 38 G Google 32 Apple 28

Brief HTML summary: The key insight is to use backtracking to systematically explore all possible arrangements. The optimal approach uses in-place swapping to generate permutations efficiently. Time: O(n! × n), Space: O(n)

Common Approaches

✓ Backtracking with Swapping

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

Use in-place swapping to generate permutations. For each position, swap it with every element from that position onwards, recurse, then swap back to restore the original state.

Generate All Permutations with Recursion

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

For each position in the result array, try placing each unused element and recursively generate the rest. This explores all possible arrangements systematically.

Backtracking with Swapping — Algorithm Steps

Start with original array
For each position, try swapping with all positions from current onwards
Recursively generate permutations for remaining positions
Backtrack by swapping back to restore original state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial

Start with original array [1,2,3]

Swap

For each position, swap with all positions ahead

Recurse

Recursively permute remaining positions

Backtrack

Swap back to restore original state

Code -

solution.c — C

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

int** result;
int* resultSizes;
int resultCount;
int maxResults;

void backtrack(int* nums, int numsSize, int* current, int depth, int* used) {
    if (depth == numsSize) {
        result[resultCount] = (int*)malloc(numsSize * sizeof(int));
        for (int i = 0; i < numsSize; i++) {
            result[resultCount][i] = current[i];
        }
        resultSizes[resultCount] = numsSize;
        resultCount++;
        return;
    }
    
    for (int i = 0; i < numsSize; i++) {
        if (used[i]) continue;
        used[i] = 1;
        current[depth] = nums[i];
        backtrack(nums, numsSize, current, depth + 1, used);
        used[i] = 0;
    }
}

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

int** solution(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    maxResults = 1;
    for (int i = 2; i <= numsSize; i++) {
        maxResults *= i;
    }
    
    result = (int**)malloc(maxResults * sizeof(int*));
    resultSizes = (int*)malloc(maxResults * sizeof(int));
    resultCount = 0;
    
    // Sort input to ensure lexicographic order
    qsort(nums, numsSize, sizeof(int), compare);
    
    int* current = (int*)malloc(numsSize * sizeof(int));
    int* used = (int*)calloc(numsSize, sizeof(int));
    
    backtrack(nums, numsSize, current, 0, used);
    
    free(current);
    free(used);
    
    *returnSize = resultCount;
    *returnColumnSizes = resultSizes;
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[10];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** res = solution(nums, numsSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", res[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! × n)

n! permutations generated, each taking O(n) time to copy

⚠ Quadratic Growth

Space Complexity

O(n)

Only recursion stack depth of O(n), result storage not counted

⚡ Linearithmic Space

464.0K Views

High Frequency

~15 min Avg. Time

14.5K 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 Swapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler