Power of Heroes - Practice Coding Problems

Power of Heroes - Problem

Array Math Dynamic Programming Sorting Prefix Sum Hard

Power of Heroes is a challenging problem that requires calculating the sum of powers for all possible groups of heroes.

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

For any group with indices i0, i1, ..., ik, the power is:
max(nums[i0], nums[i1], ..., nums[ik])² × min(nums[i0], nums[i1], ..., nums[ik])

Goal: 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.

This problem tests your understanding of mathematical optimization, sorting techniques, and efficient computation of subset contributions.

Input & Output

example_1.py — Basic Example

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

› Output: 141

💡 Note: All possible non-empty groups: {2}: 2² × 2 = 8, {1}: 1² × 1 = 1, {4}: 4² × 4 = 64, {2,1}: 2² × 1 = 4, {2,4}: 4² × 2 = 32, {1,4}: 4² × 1 = 16, {2,1,4}: 4² × 1 = 16. Total sum = 8+1+64+4+32+16+16 = 141

example_2.py — All Same Elements

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

› Output: 7

💡 Note: Since all elements are the same, every group has power = 1² × 1 = 1. There are 2³ - 1 = 7 non-empty groups, so total sum = 7

example_3.py — Single Element

$ Input: nums = [15]

› Output: 3375

💡 Note: Only one possible group: {15}. Power = 15² × 15 = 225 × 15 = 3375

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Sort Heroes by Strength

Arrange heroes in ascending order to identify contribution patterns

Calculate Each Hero's Maximum Contribution

For each hero, determine their contribution when they're the strongest in various teams

Use Mathematical Formulas

Apply prefix sums and powers of 2 to avoid brute force enumeration

Apply Modular Arithmetic

Handle large numbers using modulo 10^9 + 7 throughout calculations

Key Takeaway

🎯 Key Insight: By sorting first and using mathematical formulas, we transform an exponential problem into a linear one, calculating each element's contribution pattern instead of generating all possible subsets.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses sorting and mathematical optimization to avoid generating all 2^n subsets. By sorting the array first, we can calculate each element's contribution as the maximum using prefix sums and modular exponentiation, achieving O(n log n) time complexity instead of O(n × 2^n).

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Mathematical Optimization	O(n log n)	O(1)	Sort array and use mathematical formulas to calculate contributions efficiently
Brute Force (Generate All Subsets)	O(n × 2^n)	O(1)	Generate all possible subsets and calculate power for each

Sorting + Mathematical Optimization — Algorithm Steps

Sort the array in ascending order
For each element as potential maximum, calculate its contribution
Use prefix sums and powers of 2 to compute contributions efficiently
Apply modular arithmetic throughout to prevent overflow

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort heroes by strength: [2, 4, 6]

Calculate Contributions

For each hero as max, calculate total contribution using formulas

Use Prefix Sums

Maintain prefix sums to avoid recalculation

Apply Modular Math

Use modular arithmetic and fast exponentiation

Code -

solution.c — C

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

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

int sumOfPower(int* nums, int numsSize) {
    const int MOD = 1000000007;
    qsort(nums, numsSize, sizeof(int), compare);
    
    long long result = 0;
    long long prefixSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        long long minSum = (nums[i] * modPow(2, i, MOD) + prefixSum) % MOD;
        long long contribution = (nums[i] * nums[i] % MOD * minSum) % MOD;
        result = (result + contribution) % MOD;
        prefixSum = (prefixSum * 2 + nums[i]) % MOD;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then we iterate through array once with O(1) operations per element

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for calculations (excluding input array)

✓ Linear Space

25.8K Views

Medium-High Frequency

~35 min Avg. Time

892 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

Sorting + Mathematical Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler