Minimum Amount of Damage Dealt to Bob - Practice Coding Problems

Minimum Amount of Damage Dealt to Bob - Problem

In a strategic battle simulation, Bob faces n enemies, each with unique attack power and health. Every second follows this sequence:

Enemy Attack Phase: All alive enemies deal damage to Bob simultaneously
Bob's Counter Phase: Bob chooses one alive enemy and deals power damage to it

You need to determine the optimal order in which Bob should defeat enemies to minimize total damage taken before all enemies are eliminated.

Input: An integer power (Bob's attack damage) and two arrays damage[] and health[] where enemy i deals damage[i] per second and has health[i] HP.

Output: The minimum total damage Bob will receive.

Input & Output

basic_example.py — Python

$ Input: power = 4, damage = [1, 2, 3, 4], health = [4, 5, 6, 8]

› Output: 39

💡 Note: Optimal order is [3,2,1,0] (0-indexed). Enemy 3 has highest ratio (4/2=2.0), then enemy 2 (3/2=1.5), enemy 1 (2/2=1.0), and enemy 0 (1/1=1.0). Total damage: 10×2 + 6×2 + 3×2 + 1×1 = 39.

small_example.py — Python

$ Input: power = 1, damage = [2, 5], health = [3, 2]

› Output: 25

💡 Note: Enemy 0 ratio: 2/3 ≈ 0.67, Enemy 1 ratio: 5/2 = 2.5. Optimal order: [1,0]. Damage: 7×2 + 2×3 = 14 + 6 = 20. Wait, let me recalculate: Kill enemy 1 first (2 turns): 7×2 = 14. Then kill enemy 0 (3 turns): 2×3 = 6. Total = 20.

edge_case.py — Python

$ Input: power = 100, damage = [1], health = [1]

› Output: 1

💡 Note: Single enemy killed in 1 turn. Total damage taken is just 1×1 = 1.

Constraints

1 ≤ power ≤ 10⁴
1 ≤ n ≤ 10⁵ where n is the length of damage and health arrays
1 ≤ damage[i], health[i] ≤ 10⁶
All values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Assessment Phase

Calculate how dangerous each enemy is relative to how long it takes to eliminate them

Priority Ranking

Sort enemies by their efficiency ratio (damage per turn / turns to kill)

Execution Phase

Follow the optimal order to minimize total damage accumulation

Result

The greedy choice leads to the globally optimal solution

Key Takeaway

🎯 Key Insight: The greedy approach works because eliminating high-efficiency enemies early reduces the cumulative damage more effectively than any other strategy. This is mathematically provable through exchange arguments.

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 29

This problem is solved optimally using a greedy approach with sorting. The key insight is to calculate the efficiency ratio damage[i] / ceil(health[i] / power) for each enemy and defeat them in descending order of this ratio. This minimizes the cumulative damage by prioritizing enemies that deal high damage relative to the time needed to defeat them.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Sorting (Optimal)	O(n log n)	O(n)	Sort enemies by damage-to-time ratio and defeat in optimal order
Brute Force (Try All Orders)	O(n! × n)	O(n)	Generate all possible enemy defeat orders and simulate each to find minimum damage

Greedy Sorting (Optimal) — Algorithm Steps

Calculate time to kill each enemy: ceil(health[i] / power)
Calculate efficiency ratio: damage[i] / time_to_kill[i]
Sort enemies by efficiency ratio in descending order
Simulate battle following this order
Return total damage taken

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Ratios

Compute damage/time_to_kill for each enemy

Sort by Priority

Arrange enemies by efficiency ratio (highest first)

Simulate Battle

Follow optimal order to minimize total damage

Return Result

Total damage is mathematically optimal

Code -

solution.c — C

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

typedef struct {
    double ratio;
    int index;
    int timeToKill;
} Enemy;

int compareEnemies(const void* a, const void* b) {
    Enemy* ea = (Enemy*)a;
    Enemy* eb = (Enemy*)b;
    if (ea->ratio > eb->ratio) return -1;
    if (ea->ratio < eb->ratio) return 1;
    return 0;
}

long long minimumDamageDealt(int power, int* damage, int* health, int n) {
    Enemy* enemies = (Enemy*)malloc(n * sizeof(Enemy));
    
    // Calculate efficiency ratios
    for (int i = 0; i < n; i++) {
        int timeToKill = (health[i] + power - 1) / power;
        double ratio = (double)damage[i] / timeToKill;
        enemies[i] = (Enemy){ratio, i, timeToKill};
    }
    
    // Sort by ratio in descending order
    qsort(enemies, n, sizeof(Enemy), compareEnemies);
    
    // Simulate optimal battle
    long long totalDamage = 0;
    long long remainingDamage = 0;
    for (int i = 0; i < n; i++) {
        remainingDamage += damage[i];
    }
    
    for (int i = 0; i < n; i++) {
        totalDamage += remainingDamage * enemies[i].timeToKill;
        remainingDamage -= damage[enemies[i].index];
    }
    
    free(enemies);
    return totalDamage;
}

int main() {
    int power;
    scanf("%d", &power);
    
    int n;
    scanf("%d", &n);
    
    int* damage = (int*)malloc(n * sizeof(int));
    int* health = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &damage[i]);
    }
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &health[i]);
    }
    
    printf("%lld\n", minimumDamageDealt(power, damage, health, n));
    
    free(damage);
    free(health);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, simulation is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Space for storing enemy indices and ratios

⚡ Linearithmic Space

68.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Greedy Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler