Maximum Coins Heroes Can Collect

Maximum Coins Heroes Can Collect - Problem

Array Two Pointers Binary Search Sorting Prefix Sum Medium

There is a battle where n heroes are trying to defeat m monsters. You are given two 1-indexed arrays of positive integers heroes and monsters of length n and m, respectively.

heroes[i] is the power of the i-th hero, and monsters[i] is the power of the i-th monster. The i-th hero can defeat the j-th monster if monsters[j] <= heroes[i].

You are also given a 1-indexed array coins of length m consisting of positive integers. coins[i] is the number of coins that each hero earns after defeating the i-th monster.

Return an array ans of length n where ans[i] is the maximum number of coins that the i-th hero can collect from this battle.

Note: The health of a hero doesn't get reduced after defeating a monster. Multiple heroes can defeat a monster, but each monster can be defeated by a given hero only once.

Input & Output

Example 1 — Basic Battle

$ Input: heroes = [1,4,2], monsters = [1,2,3,4], coins = [5,10,15,20]

› Output: [5,50,15]

💡 Note: Hero 1 (power 1): defeats monster 1 (power 1) → 5 coins. Hero 2 (power 4): defeats all monsters → 5+10+15+20 = 50 coins. Hero 3 (power 2): defeats monsters 1,2 → 5+10 = 15 coins.

Example 2 — No Defeats

$ Input: heroes = [1,1], monsters = [2,3], coins = [10,20]

› Output: [0,0]

💡 Note: Both heroes have power 1, but all monsters have power ≥ 2, so no defeats possible.

Example 3 — All Powerful Hero

$ Input: heroes = [10], monsters = [1,2,3], coins = [5,10,15]

› Output: [30]

💡 Note: Hero with power 10 can defeat all monsters (1,2,3) and collect 5+10+15 = 30 coins.

Constraints

1 ≤ heroes.length, monsters.length ≤ 10⁵
1 ≤ heroes[i], monsters[i] ≤ 10⁸
1 ≤ coins[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 M Microsoft 15

The key insight is that stronger heroes can defeat all monsters that weaker heroes can defeat. By sorting monsters by power and using binary search with prefix sums, we can efficiently find how many coins each hero collects. Best approach is Sort + Binary Search. Time: O(m log m + n log m), Space: O(m)

Common Approaches

✓ Optimized

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

Brute Force

⏱️ Time: O(n × m) Space: O(1)

For every hero, iterate through all monsters, check if the hero can defeat each monster (hero power >= monster power), and sum up all the coins from defeatable monsters.

Sort and Binary Search

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

Sort monsters by their power along with corresponding coins, then for each hero use binary search to find the rightmost monster they can defeat, and use prefix sum to get total coins efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* y, int n) {
    if (n <= 1) return 0;
    
    // Collect all unique y-coordinates from segments
    int coords[2000];
    int coordCount = 0;
    
    for (int i = 0; i < n - 1; i++) {
        int y1 = y[i], y2 = y[i + 1];
        if (y1 != y2) {  // Only non-horizontal segments
            // Add y1 if not already present
            int found1 = 0;
            for (int j = 0; j < coordCount; j++) {
                if (coords[j] == y1) {
                    found1 = 1;
                    break;
                }
            }
            if (!found1) coords[coordCount++] = y1;
            
            // Add y2 if not already present
            int found2 = 0;
            for (int j = 0; j < coordCount; j++) {
                if (coords[j] == y2) {
                    found2 = 1;
                    break;
                }
            }
            if (!found2) coords[coordCount++] = y2;
        }
    }
    
    if (coordCount == 0) return 0;
    
    qsort(coords, coordCount, sizeof(int), compare);
    
    int maxIntersections = 0;
    
    // For each interval between consecutive coordinates, count intersecting segments
    for (int i = 0; i < coordCount - 1; i++) {
        // Test a point in the middle of this interval
        double testY = (coords[i] + coords[i + 1]) / 2.0;
        int intersections = 0;
        
        for (int j = 0; j < n - 1; j++) {
            double y1 = y[j], y2 = y[j + 1];
            double minY = y1 < y2 ? y1 : y2;
            double maxY = y1 > y2 ? y1 : y2;
            if (minY < testY && testY < maxY) {
                intersections++;
            }
        }
        
        if (intersections > maxIntersections) {
            maxIntersections = intersections;
        }
    }
    
    return maxIntersections;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

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