Maximum Performance of a Team

Maximum Performance of a Team - Problem

You are given two integers n and k and two integer arrays speed and efficiency both of length n. There are n engineers numbered from 1 to n.

speed[i] and efficiency[i] represent the speed and efficiency of the i-th engineer respectively.

Choose at most k different engineers out of the n engineers to form a team with the maximum performance.

The performance of a team is the sum of its engineers' speeds multiplied by the minimum efficiency among its engineers.

Return the maximum performance of this team. Since the answer can be a huge number, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 60

💡 Note: We choose engineers 2 and 5 (0-indexed) with speeds [10,5] and efficiencies [4,7]. Performance = (10+5) × min(4,7) = 15 × 4 = 60.

Example 2 — Single Engineer

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

› Output: 68

💡 Note: Choose engineer with efficiency 9 and speed 1, plus top 2 others by speed considering efficiency constraint. Best combination gives performance 68.

Example 3 — All Engineers

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

› Output: 72

💡 Note: When k equals n, we can consider all engineers. The optimal team maximizes sum of speeds × minimum efficiency across all possible combinations.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ speed[i] ≤ 10⁵
1 ≤ efficiency[i] ≤ 10⁸
1 ≤ k ≤ n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to sort engineers by efficiency in descending order, then for each engineer as the minimum efficiency, greedily select the top k speeds using a min-heap. This ensures we consider every possible minimum efficiency while maintaining optimal speed selection. Best approach uses greedy with heap. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible combinations of engineers from size 1 to k. For each combination, calculate the performance as sum of speeds multiplied by minimum efficiency. Track the maximum performance found.

Greedy with Sorting and Heap

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

Sort engineers by efficiency in descending order. For each engineer as the minimum efficiency, greedily select the k highest speed engineers (including current one) using a min-heap. This ensures we try every possible minimum efficiency while maintaining optimal speed selection.

Brute Force - Try All Combinations — Algorithm Steps

Generate all combinations of size 1 to k
For each combination, calculate sum of speeds
Find minimum efficiency in the combination
Calculate performance = speed_sum × min_efficiency
Track maximum performance

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Teams

Create all possible combinations of 1 to k engineers

Calculate Performance

For each team: sum speeds × min efficiency

Track Maximum

Keep the highest performance found

Code -

solution.c — C

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

long long findMaxForSize(int* speed, int* efficiency, int n, int size, 
                        int start, int* current, int currentSize, long long MOD) {
    if (currentSize == size) {
        long long speedSum = 0;
        int minEff = INT_MAX;
        for (int i = 0; i < currentSize; i++) {
            speedSum += speed[current[i]];
            if (efficiency[current[i]] < minEff) {
                minEff = efficiency[current[i]];
            }
        }
        return (speedSum * minEff) % MOD;
    }
    
    long long maxPerf = 0;
    for (int i = start; i < n; i++) {
        current[currentSize] = i;
        long long perf = findMaxForSize(speed, efficiency, n, size, i + 1, current, currentSize + 1, MOD);
        if (perf > maxPerf) {
            maxPerf = perf;
        }
    }
    return maxPerf;
}

long long solution(int n, int* speed, int* efficiency, int k) {
    const long long MOD = 1000000007LL;
    long long maxPerformance = 0;
    int* current = (int*)malloc(k * sizeof(int));
    
    for (int size = 1; size <= k; size++) {
        long long perf = findMaxForSize(speed, efficiency, n, size, 0, current, 0, MOD);
        if (perf > maxPerformance) {
            maxPerformance = perf;
        }
    }
    
    free(current);
    return maxPerformance;
}

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 main() {
    int n, k;
    scanf("%d", &n);
    
    int* speed = (int*)malloc(n * sizeof(int));
    int* efficiency = (int*)malloc(n * sizeof(int));
    
    // Read speed array
    char line[1000];
    scanf(" %s", line);
    // Parse [1,2,3] format
    char* token = strtok(line + 1, ",]");
    for (int i = 0; i < n; i++) {
        speed[i] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Read efficiency array
    scanf(" %s", line);
    token = strtok(line + 1, ",]");
    for (int i = 0; i < n; i++) {
        efficiency[i] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    scanf("%d", &k);
    
    printf("%lld\n", solution(n, speed, efficiency, k));
    
    free(speed);
    free(efficiency);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n combinations, each taking O(n) time to process

⚡ Linearithmic

Space Complexity

O(n)

Space for current combination and temporary calculations

⚡ Linearithmic Space

156.0K Views

Medium Frequency

~35 min Avg. Time

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