Minimum Amount of Damage Dealt to Bob - Problem

You are given an integer power and two integer arrays damage and health, both having length n.

Bob has n enemies, where enemy i will deal Bob damage[i] points of damage per second while they are alive (i.e. health[i] > 0).

Every second, after the enemies deal damage to Bob, he chooses one of the enemies that is still alive and deals power points of damage to them.

Determine the minimum total amount of damage points that will be dealt to Bob before all n enemies are dead.

Input & Output

Example 1 — Basic Case

$ Input: power = 10, damage = [10,4,15], health = [80,20,40]

› Output: 138

💡 Note: Enemy ratios: 10/8=1.25, 4/2=2.0, 15/4=3.75. Attack order [2,1,0] gives minimum damage of 138.

Example 2 — Equal Ratios

$ Input: power = 5, damage = [5,10], health = [10,20]

› Output: 30

💡 Note: Both enemies have ratio 5/2=2.5. Either order works, total damage is 30.

Example 3 — Single Enemy

$ Input: power = 20, damage = [15], health = [30]

› Output: 30

💡 Note: Only one enemy: takes 2 turns to kill, deals 15 damage per turn, total 30.

Constraints

1 ≤ power ≤ 10⁴
1 ≤ n ≤ 10⁵
1 ≤ damage[i], health[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to use a greedy approach: prioritize attacking enemies by their damage-per-time-to-kill ratio. Calculate each enemy's time to kill as ceil(health/power), then sort enemies by damage/time ratio in descending order. Attack in this optimal order to minimize total damage. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Orders

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

Generate all possible permutations of enemy defeat orders. For each permutation, simulate the battle and calculate total damage taken. Return the minimum damage across all permutations.

Greedy - Optimal Priority Order

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

Calculate the time needed to kill each enemy and sort by damage-per-time ratio. Attack enemies in descending order of this ratio to minimize total damage taken. This greedy approach gives the optimal solution.

Brute Force - Try All Orders — Algorithm Steps

Step 1: Generate all permutations of enemy indices
Step 2: For each permutation, simulate the battle turn by turn
Step 3: Track minimum damage across all simulations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orders to defeat enemies

Simulate Each Order

For each order, simulate the battle turn by turn

Find Minimum

Track the order that results in minimum damage

Code -

solution.c — C

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

long long simulateBattle(int power, int* damage, int* health, int* order, int n) {
    int* enemyHealth = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) enemyHealth[i] = health[i];
    
    long long totalDamage = 0;
    int* enemiesAlive = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) enemiesAlive[i] = 1;
    int aliveCount = n;
    int orderIdx = 0;
    
    while (aliveCount > 0) {
        // Calculate damage from all alive enemies
        long long currentDamage = 0;
        for (int i = 0; i < n; i++) {
            if (enemiesAlive[i]) {
                currentDamage += damage[i];
            }
        }
        totalDamage += currentDamage;
        
        // Find next target that's still alive
        while (orderIdx < n && !enemiesAlive[order[orderIdx]]) {
            orderIdx++;
        }
        
        if (orderIdx < n) {
            int target = order[orderIdx];
            enemyHealth[target] -= power;
            
            if (enemyHealth[target] <= 0) {
                enemiesAlive[target] = 0;
                aliveCount--;
                orderIdx++;
            }
        }
    }
    
    free(enemyHealth);
    free(enemiesAlive);
    return totalDamage;
}

void generatePermutations(int* arr, int start, int n, int** permutations, int* permCount, long long* minDamage, int power, int* damage, int* health) {
    if (start == n) {
        long long totalDamage = simulateBattle(power, damage, health, arr, n);
        if (totalDamage < *minDamage) {
            *minDamage = totalDamage;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        // Swap
        int temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        
        generatePermutations(arr, start + 1, n, permutations, permCount, minDamage, power, damage, health);
        
        // Backtrack
        temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
    }
}

long long solution(int power, int* damage, int* health, int n) {
    long long minDamage = LLONG_MAX;
    int* indices = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) indices[i] = i;
    
    int** permutations = NULL;
    int permCount = 0;
    
    generatePermutations(indices, 0, n, permutations, &permCount, &minDamage, power, damage, health);
    
    free(indices);
    return minDamage;
}

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() {
    int power;
    scanf("%d", &power);
    
    char line[1000];
    scanf(" %[^\n]", line);
    
    // Parse damage array
    int damage[100];
    int damageCount = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        damage[damageCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    scanf(" %[^\n]", line);
    
    // Parse health array
    int health[100];
    int healthCount = 0;
    token = strtok(line + 1, ",]");
    while (token != NULL) {
        health[healthCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    long long result = solution(power, damage, health, damageCount);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for current permutation and enemy states

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~35 min Avg. Time

850 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

Minimum Amount of Damage Dealt to Bob - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Orders — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler