Count the Number of Computer Unlocking Permutations

Count the Number of Computer Unlocking Permutations - Problem

You're a cybersecurity expert who needs to unlock a series of encrypted computers in a secure facility. Each computer has a complexity rating for its password, and there's a specific hierarchy for unlocking them.

The Rules:

Computer 0 is already unlocked (your starting point)
To unlock computer i, you must use a previously unlocked computer j where:

j < i (lower labeled computer)
complexity[j] < complexity[i] (simpler password helps unlock more complex one)

Goal: Count how many different valid sequences exist for unlocking all computers from 0 to n-1.

Example: If you have computers [0,1,2] with complexities [1,3,2], you could unlock them as [0,2,1] because computer 0 (complexity 1) can unlock computer 2 (complexity 2), and then computer 2 can unlock computer 1 (complexity 3).

Return the answer modulo 10^9 + 7.

Input & Output

example_1.py — Basic Case

$ Input: [1, 3, 2]

› Output: 1

💡 Note: Computers have complexities [1,3,2]. Computer 0 (complexity 1) is unlocked first. Only valid sequence: unlock computer 2 (complexity 2) using computer 0, then unlock computer 1 (complexity 3) using computer 2. This gives us permutation [0,2,1].

example_2.py — Multiple Valid Sequences

$ Input: [1, 2, 3]

› Output: 2

💡 Note: Computer 0 has complexity 1. Valid sequences: [0,1,2] (unlock 1 with 0, then 2 with 1) and [0,2,1] (unlock 2 with 0, then 1 with 2). Both work because each step follows the complexity constraint.

example_3.py — Single Computer

$ Input: [5]

› Output: 1

💡 Note: Only one computer exists (computer 0), so there's exactly one way to 'unlock' all computers: [0].

Visualization

Tap to expand

Understanding the Visualization

Initial State

Computer 0 is unlocked and ready to unlock others

Find Candidates

Identify which computers can be unlocked next based on complexity rules

Apply Constraints

Ensure each computer can only unlock those with higher complexity and ID

Count Arrangements

Calculate total valid permutations using mathematical relationships

Key Takeaway

🎯 Key Insight: The problem reduces to counting arrangements where each computer can be unlocked by a previously placed computer with both lower complexity AND lower ID number.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the complexity array dominates, DP is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Space for sorted array and DP table

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
1 ≤ complexity[i] ≤ 10⁶
All complexity values are positive integers
Computer 0 is always initially unlocked

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 25

This problem requires combinatorial analysis to count valid computer unlocking sequences. The optimal approach uses dynamic programming with complexity-based sorting to efficiently calculate the number of valid permutations in O(n log n) time, avoiding the brute force O(n!) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n!)	Generate all possible permutations and validate each one
Dynamic Programming (Optimal)	O(n log n)	O(n)	Use combinatorics and sorted complexity analysis

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of [0, 1, 2, ..., n-1]
For each permutation, simulate the unlocking process
Track which computers are unlocked at each step
For each computer to unlock, check if valid predecessor exists
Count valid permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings starting with computer 0

Validate Each

For each permutation, simulate the unlocking process

Count Valid

Keep track of permutations that follow all rules

Code -

solution.c — C

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

#define MOD 1000000007

bool isValidPermutation(int* complexity, int* perm, int n) {
    bool* unlocked = (bool*)calloc(n, sizeof(bool));
    unlocked[0] = true;
    
    for (int i = 1; i < n; i++) {
        int computer = perm[i];
        bool canUnlock = false;
        
        for (int j = 0; j < n; j++) {
            if (unlocked[j] && j < computer && complexity[j] < complexity[computer]) {
                canUnlock = true;
                break;
            }
        }
        
        if (!canUnlock) {
            free(unlocked);
            return false;
        }
        unlocked[computer] = true;
    }
    
    free(unlocked);
    return true;
}

int generatePermutations(int* complexity, int* remaining, int remainingSize, int* current, int currentSize, int n) {
    if (remainingSize == 0) {
        return isValidPermutation(complexity, current, n) ? 1 : 0;
    }
    
    int count = 0;
    for (int i = 0; i < remainingSize; i++) {
        current[currentSize] = remaining[i];
        
        int* newRemaining = (int*)malloc((remainingSize - 1) * sizeof(int));
        int idx = 0;
        for (int j = 0; j < remainingSize; j++) {
            if (j != i) {
                newRemaining[idx++] = remaining[j];
            }
        }
        
        count = (count + generatePermutations(complexity, newRemaining, remainingSize - 1, current, currentSize + 1, n)) % MOD;
        free(newRemaining);
    }
    
    return count;
}

int countValidPermutations(int* complexity, int n) {
    int* remaining = (int*)malloc((n - 1) * sizeof(int));
    for (int i = 1; i < n; i++) {
        remaining[i - 1] = i;
    }
    
    int* current = (int*)malloc(n * sizeof(int));
    current[0] = 0;
    
    int result = generatePermutations(complexity, remaining, n - 1, current, 1, n);
    
    free(remaining);
    free(current);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int complexity[100];
    int n = 0;
    
    char* token = strtok(input, "[],");
    while (token != NULL && n < 100) {
        complexity[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", countValidPermutations(complexity, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, validate each in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n!)

Store all permutations or use O(n) for recursion stack

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 1000
1 ≤ complexity[i] ≤ 10⁶
All complexity values are positive integers
Computer 0 is always initially unlocked

43.4K Views

Medium-High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler