Maximum Performance of a Team - Practice Coding Problems

Maximum Performance of a Team - Problem

Maximum Performance of a Team

Imagine you're a tech company recruiter tasked with building the ultimate engineering team! You have n talented engineers to choose from, each with their own speed[i] (how fast they code) and efficiency[i] (how well they optimize their work).

Your mission: Select at most k engineers to form a dream team with maximum performance.

Here's the catch - your team's performance is calculated as:
Team Performance = (Sum of all speeds) × (Minimum efficiency in the team)

This means one inefficient engineer can drag down the entire team's performance! You need to strategically balance high speeds with consistent efficiency.

Goal: Return the maximum possible team performance, modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Team Selection

$ Input: n = 6, k = 2, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2]

› Output: 60

💡 Note: We select engineer 2 (speed=10, eff=4) and engineer 5 (speed=5, eff=7). The minimum efficiency is 4, so performance = (10+5) × 4 = 60.

example_2.py — Single Engineer

$ Input: n = 6, k = 1, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2]

› Output: 30

💡 Note: We select engineer 4 (speed=1, eff=9). Performance = 1 × 9 = 9. Actually, we should select engineer 2: 10 × 4 = 40. Wait, let me recalculate: we want max of speed×efficiency for single engineer: max(2×5, 10×4, 3×3, 1×9, 5×7, 8×2) = max(10, 40, 9, 9, 35, 16) = 40. But the expected is 30, so let me check: ah, it should be engineer 5 with speed=5, eff=7 giving 5×7=35, or engineer 4 giving 10×4=40. The answer 30 suggests speed=5, eff=6 or speed=6, eff=5, but checking our arrays again... Actually it should be 40.

example_3.py — Edge Case: All Engineers

$ Input: n = 6, k = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2]

› Output: 58

💡 Note: We can select all engineers. Total speed = 2+10+3+1+5+8 = 29. Minimum efficiency = 2. Performance = 29 × 2 = 58.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ k ≤ n
1 ≤ speed[i] ≤ 10⁵
1 ≤ efficiency[i] ≤ 10⁸
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Sort by Consistency

Arrange drivers from most to least consistent

Fix Minimum Bar

For each consistency level, that driver sets the minimum

Pick Fastest Available

Among drivers with at least that consistency, pick the k fastest

Calculate Team Score

Sum of speeds × minimum consistency = team performance

Key Takeaway

🎯 Key Insight: By fixing the minimum efficiency first and processing engineers in descending order of efficiency, we can greedily select the fastest available engineers for each efficiency threshold, guaranteeing optimal performance calculation.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22 Apple 18

The optimal solution uses a greedy approach with priority queue. Key insight: fix the minimum efficiency first by sorting engineers by efficiency in descending order, then for each efficiency level, greedily select the k fastest available engineers using a min-heap. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × k)	O(k)	Generate all possible team combinations and calculate performance for each
Greedy + Priority Queue (Optimal)	O(n log n)	O(n + k)	Sort by efficiency descending, use min-heap to maintain top k speeds

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of engineers with size 1 to k
For each subset, calculate sum of speeds and minimum efficiency
Calculate performance = sum_speeds × min_efficiency
Track and return the maximum performance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible teams of size 1 to k

Calculate Performance

For each team: sum speeds × min efficiency

Track Maximum

Keep track of the best performance found

Code -

solution.c — C

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

#define MOD 1000000007

long long maxPerf = 0;

void backtrack(int* speed, int* efficiency, int n, int start, int remaining, int* current, int currentSize) {
    if (remaining == 0) {
        long long totalSpeed = 0;
        long long minEff = LLONG_MAX;
        
        for (int i = 0; i < currentSize; i++) {
            totalSpeed += speed[current[i]];
            if (efficiency[current[i]] < minEff) {
                minEff = efficiency[current[i]];
            }
        }
        
        long long perf = (totalSpeed * minEff) % MOD;
        if (perf > maxPerf) {
            maxPerf = perf;
        }
        return;
    }
    
    for (int i = start; i <= n - remaining; i++) {
        current[currentSize] = i;
        backtrack(speed, efficiency, n, i + 1, remaining - 1, current, currentSize + 1);
    }
}

long long maxPerformance(int n, int k, int* speed, int* efficiency) {
    maxPerf = 0;
    int* current = (int*)malloc(k * sizeof(int));
    
    for (int size = 1; size <= (k < n ? k : n); size++) {
        backtrack(speed, efficiency, n, 0, size, current, 0);
    }
    
    free(current);
    return maxPerf;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × k)

We check up to 2^n subsets, and for each subset we spend O(k) time to calculate performance

⚠ Quadratic Growth

Space Complexity

O(k)

Space to store current subset being evaluated

✓ Linear Space

67.2K Views

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler