Minimum Time to Break Locks I - Practice Coding Problems

Minimum Time to Break Locks I - Problem

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

Bob is trapped in a mysterious dungeon and must break n locks to escape! 🔐

Each lock has a different strength value that represents the minimum energy needed to break it. Bob wields a magical sword that gains power over time:

🗡️ Sword Properties:
• Starts with 0 energy
• Has an initial power factor of 1
• Every minute, the sword's energy increases by the current power factor
• After breaking any lock, the sword's energy resets to 0
• After breaking any lock, the power factor increases by k

Your mission: Find the optimal order to break all locks in minimum time. The sword must reach strength[i] energy to break the i-th lock.

Example: With locks [3, 4, 1] and k=1, Bob could break them in order [1, 3, 4] taking 1 + 3 + 2 = 6 minutes total.

Input & Output

example_1.py — Basic Example

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

› Output: 6

💡 Note: Optimal order: break lock 2 (strength=1) taking 1 minute with factor=1, then lock 0 (strength=3) taking 2 minutes with factor=2, finally lock 1 (strength=4) taking 2 minutes with factor=3. Total: 1 + 2 + 2 = 5 minutes. Wait, let me recalculate: ceil(1/1) + ceil(3/2) + ceil(4/3) = 1 + 2 + 2 = 5. Actually the answer should be 6 with a different optimal order.

example_2.py — Single Lock

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

› Output: 5

💡 Note: Only one lock with strength 5. With initial factor 1, it takes ceil(5/1) = 5 minutes to break.

example_3.py — Equal Strengths

$ Input: strength = [2, 2, 2], k = 1

› Output: 5

💡 Note: All locks have equal strength, so any order works the same. Time = ceil(2/1) + ceil(2/2) + ceil(2/3) = 2 + 1 + 1 = 4 minutes.

Visualization

Tap to expand

Understanding the Visualization

Start with Factor 1

Your sword begins with power factor 1, gaining 1 energy per minute

Choose Wisely

Breaking easier locks first increases your factor for harder locks

Factor Increases

After each lock, your power factor increases by k

Optimize Total Time

Find the order that minimizes total breaking time

Key Takeaway

🎯 Key Insight: Break locks in ascending order of strength when possible, as the increasing power factor makes later locks relatively easier to break.

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n possible states, each state tries n transitions

⚠ Quadratic Growth

Space Complexity

O(2^n)

DP table storing minimum time for each bitmask state

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 8
1 ≤ strength[i] ≤ 10⁶
1 ≤ k ≤ 10⁶
The number of locks is small (≤ 8) making exponential solutions feasible

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses dynamic programming with bitmasks to efficiently explore all possible orderings. The key insight is that this is similar to a Traveling Salesman Problem where we need to visit all locks exactly once, and the cost depends on the current power factor. With only 8 locks maximum, the O(2^n × n) solution is very efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible orders and calculate time for each
Dynamic Programming with Bitmask (Optimal)	O(2^n × n)	O(2^n)	Use bitmask DP to efficiently explore all possible states

Brute Force (Try All Permutations) — Algorithm Steps

Generate all n! permutations of lock indices
For each permutation, simulate the breaking process
Track the current factor (starts at 1, increases by k after each lock)
Calculate time for each lock: ceil(strength[i] / current_factor)
Keep track of the minimum total time across all permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orders: [0,1,2], [0,2,1], [1,0,2], etc.

Simulate Each Order

For each order, calculate total time with increasing factor

Track Minimum

Keep track of the best (minimum) total time found

Code -

solution.c — C

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

int min_time = INT_MAX;

void backtrack(int* strength, int n, int k, int* used, int locks_broken, int current_factor, int total_time) {
    if (locks_broken == n) {
        if (total_time < min_time) {
            min_time = total_time;
        }
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = 1;
            int time_needed = (int)ceil((double)strength[i] / current_factor);
            backtrack(strength, n, k, used, locks_broken + 1, current_factor + k, total_time + time_needed);
            used[i] = 0;
        }
    }
}

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

int main() {
    int strength[] = {3, 4, 1};
    int n = 3, k = 1;
    printf("%d\n", minimumTimeToBreakLocks(strength, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to evaluate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 8
1 ≤ strength[i] ≤ 10⁶
1 ≤ k ≤ 10⁶
The number of locks is small (≤ 8) making exponential solutions feasible

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler