Minimum Time to Break Locks I

Minimum Time to Break Locks I - Problem

Array Dynamic Programming Backtracking Bit Manipulation Depth-First Search Bitmask Medium

Bob is stuck in a dungeon and must break n locks, each requiring some amount of energy to break. The required energy for each lock is stored in an array called strength where strength[i] indicates the energy needed to break the i-th lock.

To break a lock, Bob uses a sword with the following characteristics:

The initial energy of the sword is 0
The initial factor x by which the energy of the sword increases is 1
Every minute, the energy of the sword increases by the current factor x
To break the i-th lock, the energy of the sword must reach at least strength[i]
After breaking a lock, the energy of the sword resets to 0, and the factor x increases by a given value k

Your task is to determine the minimum time in minutes required for Bob to break all n locks and escape the dungeon.

Input & Output

Example 1 — Basic Case

$ Input: strength = [3,4,1], k = 1

› Output: 4

💡 Note: Optimal order: Break lock 2 (1 energy, 1 minute), then lock 1 (4 energy, factor=2, so 2 minutes), then lock 0 (3 energy, factor=3, so 1 minute). Total: 1+2+1=4 minutes.

Example 2 — Higher k Value

$ Input: strength = [2,5,4], k = 2

› Output: 5

💡 Note: Break lock 0 (2 energy, 2 minutes), then lock 2 (4 energy, factor=3, so ceil(4/3)=2 minutes), then lock 1 (5 energy, factor=5, so ceil(5/5)=1 minute). Total: 2+2+1=5 minutes.

Example 3 — Single Lock

$ Input: strength = [10], k = 3

› Output: 10

💡 Note: Only one lock with strength 10, initial factor is 1, so it takes 10 minutes to break.

Constraints

1 ≤ n ≤ 8
1 ≤ strength[i] ≤ 10⁸
1 ≤ k ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 15 A Amazon 12 M Microsoft 8

The key insight is that the order of breaking locks matters significantly because each successful break increases the sword's charging factor. The optimal approach uses dynamic programming with bitmasks to try all possible sequences while memoizing subproblems. Time: O(n² × 2ⁿ), Space: O(2ⁿ).

Common Approaches

✓ Backtracking with Pruning

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

Recursively try all possible sequences but prune branches when current time already exceeds the best found solution. This reduces the search space significantly compared to brute force.

Dynamic Programming with Bitmask

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

Use a bitmask to represent which locks have been broken and memoize the minimum time for each state. For each state, try breaking each remaining lock and transition to the next state.

Try All Permutations

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

Generate all possible permutations of lock indices, calculate the total time for each permutation, and return the minimum. For each permutation, simulate breaking locks in that order while tracking the increasing factor.

Backtracking with Pruning — Algorithm Steps

Start with empty sequence and factor=1
For each remaining lock, try adding it next
Prune if current time >= best time found
Recursively continue until all locks broken

Visualization

Tap to expand

Step-by-Step Walkthrough

Explore Branch

Try breaking locks in a specific order

Prune Bad Paths

Stop if current time exceeds best found

Backtrack

Return and try different lock order

Code -

solution.c — C

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

int minTime;

void backtrack(int* strength, int n, int k, bool* used, int currentTime, int factor, int depth) {
    if (depth == n) {
        if (currentTime < minTime) {
            minTime = currentTime;
        }
        return;
    }
    
    if (currentTime >= minTime) {
        return; // Pruning
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = true;
            // Use integer ceiling division: (a + b - 1) / b instead of ceil(a/b)
            int timeNeeded = (strength[i] + factor - 1) / factor;
            backtrack(strength, n, k, used, currentTime + timeNeeded, factor + k, depth + 1);
            used[i] = false;
        }
    }
}

int solution(int* strength, int n, int k) {
    minTime = INT_MAX;
    bool* used = calloc(n, sizeof(bool));
    
    backtrack(strength, n, k, used, 0, 1, 0);
    
    free(used);
    return minTime;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int strength[20];
    int n = 0;
    char* p = line;
    
    // Skip to opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        strength[n++] = (int)strtol(p, &p, 10);
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(strength, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case still explores all permutations, but pruning helps in practice

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth is n, plus tracking used locks

✓ Linear Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 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