Find the Derangement of An Array

Find the Derangement of An Array - Problem

In combinatorial mathematics, a derangement is a permutation of the elements of a set, such that no element appears in its original position.

You are given an integer n. There is originally an array consisting of n integers from 1 to n in ascending order, return the number of derangements it can generate.

Since the answer may be huge, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Small Case

$ Input: n = 3

› Output: 2

💡 Note: Original array [1,2,3] has 2 derangements: [2,3,1] and [3,1,2]. In both cases, no element appears in its original position.

Example 2 — Base Case

$ Input: n = 1

› Output: 0

💡 Note: With only one element [1], it's impossible to create a derangement since the element must go somewhere, and the only position is its original position.

Example 3 — Larger Case

$ Input: n = 4

› Output: 9

💡 Note: For array [1,2,3,4], there are 9 valid derangements where no element is in its original position. Using formula: D(4) = 3 × (D(3) + D(2)) = 3 × (2 + 1) = 9

Constraints

1 ≤ n ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 f Facebook 12

The optimal approach uses the mathematical derangement formula D(n) = (n-1) × (D(n-1) + D(n-2)) with dynamic programming. Base cases are D(0)=1, D(1)=0. Build iteratively for O(n) time and O(1) space complexity.

Common Approaches

✓ Brute Force - Generate All Permutations

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

This approach generates all n! permutations of numbers 1 to n and checks each one to see if it's a valid derangement. A permutation is a derangement if for every position i, the element at position i is not equal to i+1.

Dynamic Programming (1D)

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

This is the optimal approach using dynamic programming with the formula D(n) = (n-1) × (D(n-1) + D(n-2)). We build the solution bottom-up iteratively, which is more efficient than recursion.

Mathematical Formula

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

Uses the mathematical formula for derangements derived from inclusion-exclusion: D(n) = n! × Σ(k=0 to n) (-1)^k / k!. This approximates to n!/e for large n, but we use the exact iterative formula for precision.

Recursion with Memoization

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

This approach uses the recursive relationship: D(n) = (n-1) × (D(n-1) + D(n-2)). We use memoization to store previously calculated results and avoid redundant computation.

Brute Force - Generate All Permutations — Algorithm Steps

Generate all permutations of [1,2,...,n]
For each permutation, check if any element equals its position+1
Count permutations where no element matches its original position

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible permutations

Check

Verify no element is in original position

Count

Count valid derangements

Code -

solution.c — C

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

const int MOD = 1000000007;
int count_derangements = 0;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void generatePermutations(int* arr, int n, int start) {
    if (start == n) {
        // Check if this is a derangement
        int isDerangement = 1;
        for (int i = 0; i < n; i++) {
            if (arr[i] == i + 1) {
                isDerangement = 0;
                break;
            }
        }
        if (isDerangement) {
            count_derangements++;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&arr[start], &arr[i]);
        generatePermutations(arr, n, start + 1);
        swap(&arr[start], &arr[i]);
    }
}

int solution(int n) {
    count_derangements = 0;
    if (n == 1) return 0;
    
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }
    
    generatePermutations(arr, n, 0);
    free(arr);
    return count_derangements % MOD;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

✓ Linear Growth

Space Complexity

O(n)

Store current permutation and recursion stack

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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