Special Permutations

Special Permutations - Problem

You are given a 0-indexed integer array nums containing n distinct positive integers. A permutation of nums is called special if:

For all indexes 0 <= i < n - 1, either nums[i] % nums[i+1] == 0 or nums[i+1] % nums[i] == 0.

Return the total number of special permutations. As the answer could be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Valid special permutations are [3,6,2] and [2,6,3]. In [3,6,2]: 6%3=0 ✓ and 6%2=0 ✓. In [2,6,3]: 6%2=0 ✓ and 6%3=0 ✓.

Example 2 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Only one permutation [1] exists, which is trivially special since there are no adjacent pairs to check.

Example 3 — No Valid Permutations

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

› Output: 0

💡 Note: No permutation is special because none of these numbers divide each other: 2%3≠0, 3%2≠0, 2%5≠0, 5%2≠0, 3%5≠0, 5%3≠0.

Constraints

1 ≤ nums.length ≤ 14
1 ≤ nums[i] ≤ 10⁹
All elements in nums are distinct

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use dynamic programming with bitmask to efficiently track which elements are used in current permutation. We build permutations incrementally, only extending with elements that satisfy the divisibility condition. Best approach is DP with Bitmask. Time: O(n² × 2ⁿ), Space: O(n × 2ⁿ)

Common Approaches

✓ Brute Force - Generate All Permutations

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

Generate all n! permutations of the array and for each permutation, check if every adjacent pair satisfies the divisibility condition. Count valid permutations.

Dynamic Programming with Bitmask

⏱️ Time: O(n² × 2ⁿ) Space: O(n × 2ⁿ)

Use dynamic programming where dp[mask][i] represents the number of ways to arrange elements indicated by the bitmask, ending with element i. Build up solutions iteratively.

Recursion with Memoization

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

Use recursive backtracking but cache results based on current position and set of used elements. This avoids recalculating permutations with same remaining elements.

Brute Force - Generate All Permutations — Algorithm Steps

Generate all possible permutations
For each permutation, check if adjacent elements are divisible
Count valid permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible permutations

Check

Verify divisibility for adjacent pairs

Count

Count valid special permutations

Code -

solution.c — C

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

#define MOD 1000000007

int count_perms = 0;

void backtrack(int* nums, int n, int* perm, int perm_size, int* used) {
    if (perm_size == n) {
        // Check if current permutation is special
        for (int i = 0; i < n - 1; i++) {
            if (perm[i] % perm[i + 1] != 0 && perm[i + 1] % perm[i] != 0) {
                return;
            }
        }
        count_perms = (count_perms + 1) % MOD;
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = 1;
            perm[perm_size] = nums[i];
            backtrack(nums, n, perm, perm_size + 1, used);
            used[i] = 0;
        }
    }
}

int solution(int* nums, int n) {
    count_perms = 0;
    int* perm = (int*)malloc(n * sizeof(int));
    int* used = (int*)calloc(n, sizeof(int));
    backtrack(nums, n, perm, 0, used);
    free(perm);
    free(used);
    return count_perms;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array
    int nums[20];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, check n-1 adjacent pairs for each

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and current permutation storage

⚡ Linearithmic Space

18.2K Views

Medium Frequency

~25 min Avg. Time

485 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 - Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler