Minimum Time to Kill All Monsters

Minimum Time to Kill All Monsters - Problem

You are given an integer array power where power[i] is the power of the i^th monster.

You start with 0 mana points, and each day you increase your mana points by gain where gain initially is equal to 1.

Each day, after gaining gain mana, you can defeat a monster if your mana points are greater than or equal to the power of that monster. When you defeat a monster:

Your mana points will be reset to 0
The value of gain increases by 1

Return the minimum number of days needed to defeat all the monsters.

Input & Output

Example 1 — Basic Case

$ Input: power = [3,1,4]

› Output: 7

💡 Note: Optimal order [4,3,1]: Day 1-4 build mana to defeat monster with power 4 (gain becomes 2), Day 5-6 build mana to defeat monster with power 3 (gain becomes 3), Day 7 defeat monster with power 1. Total: 7 days.

Example 2 — Small Array

$ Input: power = [1,1,4]

› Output: 3

💡 Note: Optimal order [1,1,4]: Day 1 defeat first monster (gain=2), Day 2 defeat second monster (gain=3), Day 3 defeat monster with power 4 (have 3 mana, need 4, so gain 3 more = 6 total). Total: 3 days.

Example 3 — Single Monster

$ Input: power = [2]

› Output: 2

💡 Note: Only one monster with power 2. Need 2 days to build enough mana (gain=1 each day). Total: 2 days.

Constraints

1 ≤ power.length ≤ 17
1 ≤ power[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32

The key insight is that the order of defeating monsters matters significantly - defeating weaker monsters first increases your daily mana gain, making stronger monsters easier to defeat later. Best approach is Dynamic Programming with Bitmask to try all orders efficiently. Time: O(2ⁿ × n), Space: O(2ⁿ).

Common Approaches

✓ Brute Force Recursion

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

Generate all permutations of monster defeat orders and calculate the minimum days needed. For each permutation, simulate the process day by day.

Dynamic Programming with Bitmask

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

Use dynamic programming with bitmask to represent which monsters are defeated. Cache results for each state (defeated monsters, current gain) to avoid redundant calculations.

Optimized DP with State Pruning

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

Optimize the DP approach by using better state representations, early pruning of suboptimal paths, and more efficient transitions between states.

Brute Force Recursion — Algorithm Steps

Generate all permutations of monster indices
For each permutation, simulate defeating monsters in that order
Track days, mana, and gain for each simulation
Return minimum days across all permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orders to defeat monsters

Simulate Each Order

For each order, simulate day-by-day combat

Find Minimum

Return the order requiring fewest days

Code -

solution.c — C

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

int minDays = INT_MAX;

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

void permute(int* power, int* indices, int n, int start) {
    if (start == n) {
        int days = 0, mana = 0, gain = 1;
        for (int i = 0; i < n; i++) {
            int monsterPower = power[indices[i]];
            while (mana < monsterPower) {
                mana += gain;
                days++;
            }
            mana = 0;
            gain++;
        }
        if (days < minDays) {
            minDays = days;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&indices[start], &indices[i]);
        permute(power, indices, n, start + 1);
        swap(&indices[start], &indices[i]);
    }
}

int solution(int* power, int n) {
    minDays = INT_MAX;
    int* indices = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) indices[i] = i;
    
    permute(power, indices, n, 0);
    free(indices);
    return minDays;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int power[20], n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        power[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", solution(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 permutation storage

✓ Linear Space

28.5K 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler