Minimum Time to Kill All Monsters - Practice Coding Problems

Minimum Time to Kill All Monsters - Problem

The Monster Hunter's Dilemma

You're a brave adventurer facing an array of monsters, each with a specific power[i] value representing the i-th monster's strength. Your journey begins with 0 mana points and a humble gain = 1 mana regeneration rate.

Daily Mechanics:

Each day, you gain gain mana points
After gaining mana, you can defeat any monster if your current mana ≥ monster's power
Upon defeating a monster: your mana resets to 0, but your gain increases by 1

Goal: Find the minimum number of days needed to defeat all monsters.

Strategy Matters! The order in which you defeat monsters significantly impacts the total time needed. Choose wisely!

Input & Output

example_1.py — Basic Case

$ Input: [3, 1, 4]

› Output: 4

💡 Note: Optimal strategy: Defeat monster with power 1 first (takes 1 day), then gain=2. Defeat monster with power 3 (takes 2 more days), then gain=3. Finally defeat monster with power 4 (takes 2 more days). Total: 1+2+2 = 5 days. Wait, let me recalculate... Actually, defeating power 1 first: day 1 we have mana=1, defeat it. Then gain=2. For power 3: day 2 mana=2, day 3 mana=4, defeat it. Then gain=3. For power 4: day 4 mana=3, day 5 mana=6, defeat it. But we can do better by starting with power 3: day 1 mana=1, day 2 mana=2, day 3 mana=3, defeat power 3. Then gain=2. Day 4 mana=2, defeat power 1. Then gain=3. Power 4 would take 2 more days, total = 4 days.

example_2.py — Single Monster

$ Input: [5]

› Output: 5

💡 Note: With only one monster of power 5, we need to accumulate mana day by day: Day 1: mana=1, Day 2: mana=2, Day 3: mana=3, Day 4: mana=4, Day 5: mana=5. We can defeat the monster on day 5.

example_3.py — Multiple Weak Monsters

$ Input: [1, 1, 1]

› Output: 3

💡 Note: All monsters have power 1. Day 1: mana=1, defeat first monster, gain becomes 2. Day 2: mana=2, defeat second monster, gain becomes 3. Day 3: mana=3, defeat third monster. Total: 3 days.

Visualization

Tap to expand

Understanding the Visualization

Initial State

Start with 0 mana and gain=1. Plan your battle sequence wisely.

Daily Progress

Each day, gain mana equal to your current gain rate. Attack when ready!

Victory Rewards

After defeating a monster, mana resets to 0 but gain increases by 1.

Strategic Planning

Use DP with bitmasks to find the optimal battle sequence.

Key Takeaway

🎯 Key Insight: The order of defeating monsters significantly impacts the total time. Generally, defeating weaker monsters first allows you to build up your mana gain rate faster, leading to more efficient victories against stronger monsters later!

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and current path storage

⚡ Linearithmic Space

Constraints

1 ≤ power.length ≤ 17
1 ≤ power[i] ≤ 10⁹
Order matters: Different defeat sequences lead to different total days

Asked in

G Google 34 f Meta 28 a Amazon 22 ⊞ Microsoft 19

The optimal solution uses Dynamic Programming with Bitmasks to efficiently explore all possible monster defeat sequences. Each bitmask represents a unique combination of defeated monsters, and we calculate the minimum days for each state. The key insight is that the order matters - defeating weaker monsters first generally leads to faster overall completion due to increased mana gain rates.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Try every possible order of defeating monsters using recursion
Dynamic Programming with Bitmask (Optimal)	O(n² × 2ⁿ)	O(2ⁿ)	Use DP with bitmasks to efficiently explore all monster defeat sequences

Brute Force (Try All Permutations) — Algorithm Steps

Use recursion to generate all possible monster defeat orders
For each permutation, simulate the daily mana gain and monster defeats
Track the minimum days across all permutations
Return the global minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Orders

Create all n! permutations of monster defeat sequences

Simulate Each Order

For each permutation, simulate day-by-day monster defeats

Track Minimum

Keep track of the minimum days across all simulations

Code -

solution.c — C

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

int simulate(int* order, int n) {
    int days = 0, gain = 1, mana = 0;
    
    for (int i = 0; i < n; i++) {
        while (mana < order[i]) {
            days++;
            mana += gain;
        }
        mana = 0;
        gain++;
    }
    
    return days;
}

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

void generatePermutations(int* arr, int start, int n, int* minDays) {
    if (start == n) {
        int days = simulate(arr, n);
        if (days < *minDays) {
            *minDays = days;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&arr[start], &arr[i]);
        generatePermutations(arr, start + 1, n, minDays);
        swap(&arr[start], &arr[i]);
    }
}

int minimumTime(int* power, int n) {
    int minDays = INT_MAX;
    generatePermutations(power, 0, n, &minDays);
    return minDays;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and current path storage

⚡ Linearithmic Space

Constraints

1 ≤ power.length ≤ 17
1 ≤ power[i] ≤ 10⁹
Order matters: Different defeat sequences lead to different total days

28.4K Views

Medium-High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler