Permutations III

Permutations III - Problem

Array Backtracking Medium

Given an integer n, an alternating permutation is a permutation of the first n positive integers such that no two adjacent elements are both odd or both even.

Return all such alternating permutations sorted in lexicographical order.

For example, if n = 4, the integers are [1, 2, 3, 4]. A valid alternating permutation would be [1, 2, 3, 4] since adjacent pairs (1,2), (2,3), and (3,4) alternate between odd and even.

Input & Output

Example 1 — Basic Case

$ Input: n = 4

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

💡 Note: For n=4, we need permutations of [1,2,3,4] where no adjacent elements have the same parity. Valid permutations alternate between odd and even numbers.

Example 2 — Small Case

$ Input: n = 3

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

💡 Note: For n=3 with numbers [1,2,3]: [1,2,3] works (odd-even-odd), and [3,2,1] works (odd-even-odd). [2,3,1] doesn't work because 3 and 1 are both odd.

Example 3 — Edge Case

$ Input: n = 1

› Output: [[1]]

💡 Note: Single element always forms valid alternating permutation since there are no adjacent pairs to violate constraint

Constraints

0 ≤ n ≤ 8
Result must be sorted in lexicographical order

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22

Brief HTML summary: The key insight is to use backtracking to generate only valid alternating permutations by checking the odd-even constraint at each step. Best approach is optimized backtracking which prunes invalid branches early. Time: O(valid permutations × n), Space: O(n)

Common Approaches

✓ Generate All Permutations

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

Create all n! permutations of numbers 1 to n, then check each one to see if it satisfies the alternating odd-even constraint.

Optimized Backtracking

⏱️ Time: O(valid permutations × n) Space: O(n)

Use backtracking to generate only valid alternating permutations. At each step, only add numbers that maintain the alternating constraint, avoiding the need to check invalid complete permutations.

Generate All Permutations — Algorithm Steps

Generate all permutations of [1,2,...,n]
For each permutation, check if adjacent elements alternate odd/even
Keep only valid alternating permutations
Sort results lexicographically

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible arrangements

Check Each

Validate alternating constraint

Filter Valid

Keep only alternating permutations

Code -

solution.c — C

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

static int result[10000][10];
static int resultCount = 0;
static int n_global;

int compare(const void *a, const void *b) {
    int *arr1 = (int*)a;
    int *arr2 = (int*)b;
    
    for (int i = 0; i < n_global; i++) {
        if (arr1[i] != arr2[i]) {
            return arr1[i] - arr2[i];
        }
    }
    return 0;
}

void permute(int nums[], int start, int n) {
    if (start == n) {
        // Check if alternating
        int valid = 1;
        for (int i = 0; i < n - 1; i++) {
            if ((nums[i] % 2) == (nums[i + 1] % 2)) {
                valid = 0;
                break;
            }
        }
        if (valid) {
            for (int i = 0; i < n; i++) {
                result[resultCount][i] = nums[i];
            }
            resultCount++;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        int temp = nums[start];
        nums[start] = nums[i];
        nums[i] = temp;
        
        permute(nums, start + 1, n);
        
        temp = nums[start];
        nums[start] = nums[i];
        nums[i] = temp;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    n_global = n;
    resultCount = 0;
    
    if (n == 0) {
        printf("[]\n");
        return 0;
    }
    
    int nums[n];
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }
    
    permute(nums, 0, n);
    
    qsort(result, resultCount, sizeof(result[0]), compare);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", result[i][j]);
            if (j < n - 1) printf(",");
        }
        printf("]");
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, check each one takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n!)

Store all permutations and valid results

⚠ Quadratic 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler