Power of Heroes

Power of Heroes - Problem

Array Math Dynamic Programming Sorting Prefix Sum Hard

You are given a 0-indexed integer array nums representing the strength of some heroes. The power of a group of heroes is defined as follows:

Let i₀, i₁, ... ,iₖ be the indices of the heroes in a group. Then, the power of this group is max(nums[i₀], nums[i₁], ... ,nums[iₖ])² × min(nums[i₀], nums[i₁], ... ,nums[iₖ]).

Return the sum of the power of all non-empty groups of heroes possible. Since the sum could be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,1,4]

› Output: 141

💡 Note: All possible groups: [2]→8, [1]→1, [4]→64, [2,1]→4, [2,4]→32, [1,4]→16, [2,1,4]→16. Sum = 8+1+64+4+32+16+16 = 141

Example 2 — Minimum Size

$ Input: nums = [1]

› Output: 1

💡 Note: Only one group [1] with power = 1² × 1 = 1

Example 3 — Equal Elements

$ Input: nums = [3,3]

› Output: 81

💡 Note: Groups: [3] (first) → 27, [3] (second) → 27, [3,3] → 27. Sum = 27+27+27 = 81

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 A Amazon 12 M Meta 8

The key insight is that after sorting the array, we can mathematically calculate how many times each element appears as minimum or maximum in different subsets. The optimal approach uses sorting with contribution counting to avoid generating all 2ⁿ subsets explicitly. Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Generate All Subsets

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

For each possible subset of heroes, find the minimum and maximum values, calculate the power using the formula max² × min, and sum all powers. This approach checks every possible combination of heroes.

Optimal: Prefix Sum with Contribution Counting

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

After sorting, we calculate how many times each element contributes as minimum and maximum across all subsets. Using prefix sums and mathematical formulas, we can compute the total power sum in linear time after sorting.

Sort + Mathematical Optimization

⏱️ Time: O(n²) Space: O(1)

After sorting the array, we can determine how many times each element appears as minimum or maximum in different subsets. This allows us to calculate the contribution of each element mathematically without generating all subsets explicitly.

Brute Force - Generate All Subsets — Algorithm Steps

Generate all 2ⁿ - 1 non-empty subsets
For each subset, find min and max elements
Calculate power = max² × min
Add to total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible combinations of heroes

Calculate Power

For each subset, find min, max and compute power

Sum Powers

Add all powers together with modulo

Code -

solution.c — C

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

static int nums[20];
static int subset[20];

int solution(int* nums, int n) {
    const int MOD = 1000000007;
    long long total = 0;
    
    // Generate all non-empty subsets using bit manipulation
    for (int mask = 1; mask < (1 << n); mask++) {
        int subsetSize = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = nums[i];
            }
        }
        
        int minVal = subset[0];
        int maxVal = subset[0];
        for (int i = 0; i < subsetSize; i++) {
            if (subset[i] < minVal) minVal = subset[i];
            if (subset[i] > maxVal) maxVal = subset[i];
        }
        
        long long power = ((long long)maxVal * maxVal % MOD * minVal) % MOD;
        total = (total + power) % MOD;
    }
    
    return total;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* p = line;
    
    // Skip to first digit
    while (*p && (*p < '0' || *p > '9')) p++;
    
    // Parse numbers
    while (*p) {
        if (*p >= '0' && *p <= '9') {
            nums[n++] = (int)strtol(p, &p, 10);
        } else {
            p++;
        }
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

Generate 2ⁿ subsets, each taking O(n) time to find min/max

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and temporary subset storage

✓ Linear Space

18.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler