Beautiful Arrangement

Beautiful Arrangement - Problem

Suppose you have n integers labeled 1 through n. A permutation of those n integers perm (1-indexed) is considered a beautiful arrangement if for every i (1 <= i <= n), either of the following is true:

perm[i] is divisible by i
i is divisible by perm[i]

Given an integer n, return the number of the beautiful arrangements that you can construct.

Input & Output

Example 1 — Small Case

$ Input: n = 2

› Output: 2

💡 Note: Both [1,2] and [2,1] are beautiful: 1%1=0, 2%2=0 for first; 2%1=0, 1%2≠0 but 2%1=0 for second

Example 2 — Moderate Case

$ Input: n = 3

› Output: 3

💡 Note: Valid arrangements are [1,2,3], [2,1,3], and [3,2,1]. For [1,2,3]: 1%1=0, 2%2=0, 3%3=0. For [2,1,3]: 2%1=0, 1%2≠0 but 2%1=0, 3%3=0. For [3,2,1]: 3%1=0, 2%2=0, 1%3≠0 but 3%1=0. All conditions satisfied.

Example 3 — Single Element

$ Input: n = 1

› Output: 1

💡 Note: Only arrangement [1] where 1%1=0, so it's beautiful

Constraints

1 ≤ n ≤ 15

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use backtracking with early pruning to avoid generating invalid arrangements. The beautiful arrangement condition (either perm[i] % i == 0 OR i % perm[i] == 0) allows us to skip many branches during recursion. Best approach is backtracking with memoization using bitmask to represent used numbers. Time: O(k), Space: O(n) where k is the actual number of valid arrangements.

Common Approaches

✓ Backtracking with Pruning

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

Use recursive backtracking to place numbers one position at a time. When a number doesn't satisfy the beautiful arrangement condition at current position, skip it without exploring further.

Generate All Permutations

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

Create every possible permutation of numbers 1 to n, then check each one to see if it satisfies the beautiful arrangement conditions at every position.

Memoized Backtracking

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

Enhance backtracking with memoization using bitmask to represent which numbers are used. Cache results for each (position, mask) state to avoid recomputing.

Backtracking with Pruning — Algorithm Steps

Start with empty arrangement
For each position, try all unused numbers
If number satisfies condition, place it and recurse
Backtrack when no valid numbers remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 1

Try numbers that satisfy condition at position 1

Position 2

For each valid choice, try remaining numbers

Prune Early

Skip invalid paths without full exploration

Code -

solution.c — C

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

int backtrack(int pos, int n, bool* used) {
    if (pos > n) {
        return 1;
    }
    
    int count = 0;
    for (int num = 1; num <= n; num++) {
        if (!used[num] && (num % pos == 0 || pos % num == 0)) {
            used[num] = true;
            count += backtrack(pos + 1, n, used);
            used[num] = false;
        }
    }
    
    return count;
}

int solution(int n) {
    bool* used = (bool*)calloc(n + 1, sizeof(bool));
    int result = backtrack(1, n, used);
    free(used);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

k is number of valid arrangements, much less than n!

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth n plus visited array

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~25 min Avg. Time

1.8K 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