Cracking the Safe

Cracking the Safe - Problem

There is a safe protected by a password. The password is a sequence of n digits where each digit can be in the range [0, k-1].

The safe has a peculiar way of checking the password. When you enter in a sequence, it checks the most recent n digits that were entered each time you type a digit.

For example, the correct password is "345" and you enter in "012345":

After typing 0, the most recent 3 digits is "0", which is incorrect.
After typing 1, the most recent 3 digits is "01", which is incorrect.
After typing 2, the most recent 3 digits is "012", which is incorrect.
After typing 3, the most recent 3 digits is "123", which is incorrect.
After typing 4, the most recent 3 digits is "234", which is incorrect.
After typing 5, the most recent 3 digits is "345", which is correct and the safe unlocks.

Return any string of minimum length that will unlock the safe at some point of entering it.

Input & Output

Example 1 — Basic Case

$ Input: n = 1, k = 2

› Output: 01

💡 Note: All passwords are single digits: 0, 1. String "01" contains both at positions 0 and 1.

Example 2 — Two Digits

$ Input: n = 2, k = 2

› Output: 00110

💡 Note: All passwords: 00, 01, 10, 11. String "00110" contains: 00 at position 0-1, 01 at position 1-2, 11 at position 2-3, 10 at position 3-4.

Example 3 — Edge Case

$ Input: n = 1, k = 1

› Output: 0

💡 Note: Only one possible password: 0. String "0" contains it at position 0.

Constraints

1 ≤ n ≤ 4
1 ≤ k ≤ 10
1 ≤ kⁿ ≤ 4096

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to model this as finding an Eulerian path in a de Bruijn graph. Best approach is DFS with graph theory which visits each password exactly once. Time: O(k^n), Space: O(k^n)

Common Approaches

✓ Brute Force DFS

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

Generate all possible password combinations and use DFS to find a sequence that contains each password exactly once. This approach explores all possibilities systematically.

Optimized DFS with Graph Theory

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

Transform the problem into finding an Eulerian path in a de Bruijn graph where nodes are (n-1)-digit strings and edges represent n-digit passwords. This is much more efficient than brute force.

Brute Force DFS — Algorithm Steps

Generate all possible n-digit passwords
Use DFS to find sequence containing each password
Backtrack when stuck and try different paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Passwords

Create all possible n-digit passwords

DFS Search

Try building sequences that visit each password

Backtrack

When stuck, backtrack and try different paths

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_LEN 10000

typedef struct {
    int next_node;
    int digit;
} Edge;

typedef struct {
    Edge edges[20];
    int count;
} AdjList;

char* solution(int n, int k) {
    char* result = (char*)malloc(MAX_LEN * sizeof(char));
    
    if (n == 1) {
        for (int i = 0; i < k; i++) {
            result[i] = '0' + i;
        }
        result[k] = '\0';
        return result;
    }
    
    // Calculate total nodes
    int totalNodes = 1;
    for (int i = 0; i < n-1; i++) {
        totalNodes *= k;
    }
    
    // Create nodes
    static char nodes[MAX_NODES][10];
    for (int i = 0; i < totalNodes; i++) {
        int temp = i;
        int pos = n-2;
        for (int j = 0; j < n-1; j++) {
            nodes[i][pos--] = '0' + (temp % k);
            temp /= k;
        }
        nodes[i][n-1] = '\0';
    }
    
    // Build adjacency list
    static AdjList graph[MAX_NODES];
    for (int i = 0; i < totalNodes; i++) {
        graph[i].count = 0;
        for (int digit = 0; digit < k; digit++) {
            char nextNode[10];
            strcpy(nextNode, nodes[i] + 1);
            nextNode[strlen(nextNode)] = '0' + digit;
            nextNode[strlen(nextNode)] = '\0';
            
            // Find index of nextNode
            int nextIdx = -1;
            for (int j = 0; j < totalNodes; j++) {
                if (strcmp(nodes[j], nextNode) == 0) {
                    nextIdx = j;
                    break;
                }
            }
            
            graph[i].edges[graph[i].count].next_node = nextIdx;
            graph[i].edges[graph[i].count].digit = digit;
            graph[i].count++;
        }
    }
    
    // Find Eulerian path using Hierholzer's algorithm
    static int stack[MAX_LEN];
    static int path[MAX_LEN];
    int stackTop = 0;
    int pathLen = 0;
    
    stack[stackTop++] = 0; // Start from node 0
    
    while (stackTop > 0) {
        int curr = stack[stackTop-1];
        if (graph[curr].count > 0) {
            Edge edge = graph[curr].edges[--graph[curr].count];
            stack[stackTop++] = edge.next_node;
        } else {
            path[pathLen++] = stack[--stackTop];
        }
    }
    
    // Reverse path
    for (int i = 0; i < pathLen/2; i++) {
        int temp = path[i];
        path[i] = path[pathLen-1-i];
        path[pathLen-1-i] = temp;
    }
    
    // Build result string
    strcpy(result, nodes[path[0]]);
    int resultLen = strlen(result);
    
    for (int i = 1; i < pathLen; i++) {
        char* prevNode = nodes[path[i-1]];
        char* currNode = nodes[path[i]];
        
        for (int digit = 0; digit < k; digit++) {
            char testNode[10];
            strcpy(testNode, prevNode + 1);
            testNode[strlen(testNode)] = '0' + digit;
            testNode[strlen(testNode)] = '\0';
            
            if (strcmp(testNode, currNode) == 0) {
                result[resultLen++] = '0' + digit;
                break;
            }
        }
    }
    
    result[resultLen] = '\0';
    return result;
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    char* result = solution(n, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n × n!)

k^n possible passwords, factorial time to arrange them

✓ Linear Growth

Space Complexity

O(k^n)

Recursion stack depth and visited set storage

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~35 min Avg. Time

892 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 DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler