Eliminate Maximum Number of Monsters - Problem

You are playing a video game where you are defending your city from a group of n monsters. You are given a 0-indexed integer array dist of size n, where dist[i] is the initial distance in kilometers of the i^th monster from the city.

The monsters walk toward the city at a constant speed. The speed of each monster is given to you in an integer array speed of size n, where speed[i] is the speed of the i^th monster in kilometers per minute.

You have a weapon that, once fully charged, can eliminate a single monster. However, the weapon takes one minute to charge. The weapon is fully charged at the very start.

You lose when any monster reaches your city. If a monster reaches the city at the exact moment the weapon is fully charged, it counts as a loss, and the game ends before you can use your weapon.

Return the maximum number of monsters that you can eliminate before you lose, or n if you can eliminate all the monsters before they reach the city.

Input & Output

Example 1 — Basic Case

$ Input: dist = [1,3,4], speed = [1,1,1]

› Output: 3

💡 Note: Monster 0 arrives at time 1, Monster 1 at time 3, Monster 2 at time 4. We can eliminate Monster 0 at time 0→1, Monster 1 at time 1→2, and Monster 2 at time 2→3. All 3 monsters can be eliminated.

Example 2 — All Monsters Eliminated

$ Input: dist = [3,2,4], speed = [5,3,2]

› Output: 1

💡 Note: Arrival times: Monster 0 at 0.6min, Monster 1 at 0.67min, Monster 2 at 2min. We eliminate Monster 0 at time 0→1, but Monster 1 arrives at 0.67min which is before our weapon finishes charging at time 1, so we lose.

Example 3 — Early Arrival

$ Input: dist = [4,2,3], speed = [2,1,1]

› Output: 3

💡 Note: Arrival times: Monster 0 at 2min, Monster 1 at 2min, Monster 2 at 3min. We can eliminate Monster 0 at time 0→1, Monster 1 at time 1→2, and Monster 2 at time 2→3. All 3 monsters can be eliminated.

Constraints

n == dist.length == speed.length
1 ≤ n ≤ 10⁵
1 ≤ dist[i], speed[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 A Apple 6

The key insight is that we should always eliminate the monster that will arrive soonest to maximize our survival time. The optimal approach uses a greedy strategy: calculate each monster's arrival time (distance/speed), sort by arrival time, then eliminate monsters in that order until one arrives before we can charge our weapon. Time: O(n log n), Space: O(n)

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force - Try All Orders

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

Generate all permutations of monster elimination orders. For each order, simulate the elimination process and check how many monsters can be eliminated before any reaches the city. This explores every possible strategy.

Greedy - Eliminate Most Urgent First

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

Calculate the arrival time for each monster (distance/speed). Sort monsters by arrival time and eliminate them in that order. This greedy approach works because eliminating the most urgent threat first maximizes our chances of survival.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    double arrivalTime;
    int index;
} Monster;

int compareMonsters(const void* a, const void* b) {
    Monster* ma = (Monster*)a;
    Monster* mb = (Monster*)b;
    if (ma->arrivalTime < mb->arrivalTime) return -1;
    if (ma->arrivalTime > mb->arrivalTime) return 1;
    return 0;
}

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 eliminateMaximumMonsters(int* dist, int distSize, int* speed, int speedSize) {
    if (distSize == 0) return 0;
    
    Monster monsters[10000];
    
    for (int i = 0; i < distSize; i++) {
        monsters[i].arrivalTime = (double)dist[i] / speed[i];
        monsters[i].index = i;
    }
    
    qsort(monsters, distSize, sizeof(Monster), compareMonsters);
    
    int eliminated = 0;
    double currentTime = 0.0;
    
    for (int i = 0; i < distSize; i++) {
        if (currentTime < monsters[i].arrivalTime) {
            eliminated++;
            currentTime += 1.0;
        } else {
            break;
        }
    }
    
    return eliminated;
}

int main() {
    char line1[10000], line2[10000];
    int dist[10000], speed[10000];
    int distSize, speedSize;
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    line1[strcspn(line1, "\n")] = '\0';
    line2[strcspn(line2, "\n")] = '\0';
    
    parseArray(line1, dist, &distSize);
    parseArray(line2, speed, &speedSize);
    
    int result = eliminateMaximumMonsters(dist, distSize, speed, speedSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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