Permutations IV

Permutations IV - Problem

Given two integers, n and k, 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 the k-th alternating permutation sorted in lexicographical order. If there are fewer than k valid alternating permutations, return an empty list.

An alternating permutation alternates between odd and even numbers at adjacent positions. For example, [1,2,3,4] is alternating because 1(odd), 2(even), 3(odd), 4(even) alternate.

Input & Output

Example 1 — Basic Case

$ Input: n = 4, k = 2

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

💡 Note: For n=4, alternating permutations start with odd or even. The valid permutations in lexicographical order are [1,2,3,4], [1,2,4,3], [1,4,3,2], etc. The 2nd one is [1,2,4,3].

Example 2 — First Permutation

$ Input: n = 3, k = 1

› Output: [1,2,3]

💡 Note: For n=3, we have odd=[1,3] and even=[2]. Only pattern O-E-O is valid. The lexicographically first alternating permutation is [1,2,3].

Example 3 — Invalid k

$ Input: n = 2, k = 5

› Output: []

💡 Note: For n=2, we have [1,2] and [2,1] as the only alternating permutations. Since k=5 > 2 total permutations, return empty list.

Constraints

1 ≤ n ≤ 15
1 ≤ k ≤ 10⁶
If fewer than k alternating permutations exist, return empty list

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 🍎 Apple 12

The key insight is that alternating permutations have a specific structure where odd and even numbers must alternate positions. The optimal approach uses mathematical construction to directly compute the k-th permutation without generating all possibilities. Time: O(n²), Space: O(n)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(n! / 2ⁿ) Space: O(n)

Use backtracking to generate permutations one by one, checking the alternating constraint during construction to prune invalid branches early. Stop when we find the k-th valid permutation.

Generate All Permutations

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

Generate all n! permutations of numbers 1 to n, filter those that satisfy the alternating constraint, sort lexicographically, and return the k-th valid permutation.

Mathematical Construction

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

Analyze the pattern of alternating permutations mathematically. For n elements, separate odd and even numbers, then use combinatorial mathematics to directly compute the k-th valid arrangement without generating all permutations.

Backtracking with Pruning — Algorithm Steps

Start with empty permutation
For each position, try all unused numbers
Check alternating constraint before recursing
Count valid permutations until we reach k-th

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Numbers

For each position, try valid numbers

Check Constraint

Verify alternating odd/even pattern

Prune Early

Stop invalid branches immediately

Code -

solution.c — C

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

int* result;
int result_size = 0;
int count_found = 0;

bool backtrack(int n, int k, int* current, int pos, bool* used) {
    if (count_found >= k) return true;
    
    if (pos == n) {
        count_found++;
        if (count_found == k) {
            for (int i = 0; i < n; i++) {
                result[i] = current[i];
            }
            result_size = n;
        }
        return count_found >= k;
    }
    
    for (int num = 1; num <= n; num++) {
        if (used[num]) continue;
        
        // Check alternating constraint
        if (pos > 0) {
            if ((current[pos-1] % 2) == (num % 2)) {
                continue;
            }
        }
        
        current[pos] = num;
        used[num] = true;
        
        if (backtrack(n, k, current, pos + 1, used)) {
            return true;
        }
        
        used[num] = false;
    }
    
    return false;
}

int* solution(int n, int k, int* returnSize) {
    *returnSize = 0;
    if (n == 0) return NULL;
    
    result = (int*)malloc(n * sizeof(int));
    result_size = 0;
    count_found = 0;
    
    int* current = (int*)malloc(n * sizeof(int));
    bool* used = (bool*)calloc(n + 1, sizeof(bool));
    
    backtrack(n, k, current, 0, used);
    
    *returnSize = result_size;
    
    free(current);
    free(used);
    
    return result_size > 0 ? result : NULL;
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    
    int returnSize;
    int* res = solution(n, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", res[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    if (res) free(res);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! / 2ⁿ)

Pruning reduces search space significantly by eliminating invalid branches early

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth is n, plus arrays for current permutation and used flags

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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 Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler