Leetcode 1383 最大的团队表现值

1. 题目描述

给定两个整数 n 和 k，以及两个长度为 n 的整数数组 speed 和 efficiency。现有 n 名工程师，编号从 1 到 n。其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。

从这 n 名工程师中最多选择 k 名不同的工程师，使其组成的团队具有最大的团队表现值。

团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。

请你返回该团队的​​​​​​最大团队表现值，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。

示例 1：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。

示例 2：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
输出：68
解释：
此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。

示例 3：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
输出：72

2. 我的尝试

题目要求我们最优化速度和和效率最小值的乘积。变化的量有两个，一个是速度，一个是效率。我们可以枚举效率的最小值⁡$e_{\min }$ ，在所有效率大于 $e_{\min }$ 的工程师中选取不超过 $k-1$ 个，让他们的速度和最大。

• 为什么是 $k-1$ 个？ 因为最小值 $e_{\min }$代表的工程师是必选，加起来一共 $k$个，所以剩下只要选 $k-1$ 个。

• 如何满足速度和最大？ 因为 speed[i] > 0，所以只需要选效率大于 $e_{\min }$ 中速度最大的 $k-1$ 个，如果效率大于$e_{\min }$ 的元素小于 $k-1$，就全取。

具体地，我们可以对工程师先按照效率从高到低的规则排序，然后从前往后枚举这个序列中的元素作为$e_{\min }$ ，这样可以保证前面的元素的效率都比当前这个工程师高，然后维护一个以速度为关键字的小根堆，存放前面已经枚举过的元素中速度前 $k-1$ 大的，动态维护这个堆的速度和，一轮枚举后，我们可以得到乘积最大值。

• 为什么是小根堆？ 因为我们要动态维护前 $k-1$ 大的元素，当堆内的元素超过 $k-1$ 的时候，我们可以从堆顶 ·pop· 掉比较小的元素，保证最大的 $k-1$ 个元素还在堆中。

const int MOD = 1e9 + 7;
typedef long long ll;

struct Engineer{
    int speed, efficiency;
    bool operator <(const Engineer &o) {return efficiency > o.efficiency;}
};

class Solution {
public:
    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
        ll res = 0;
        ll sumS = 0;
        vector<Engineer> engineers;
        priority_queue<int, vector<int>, greater<int>> heap;

        for (int i = 0; i < n; i ++)
            engineers.push_back({speed[i], efficiency[i]});

        sort(engineers.begin(), engineers.end());

        for (int i = 0; i < n; i++) {
            int e = engineers[i].efficiency, s = engineers[i].speed;

            sumS += s;
            res = max(res, e * sumS);

            heap.push(s);
            if (heap.size() >= k) {
                sumS -= heap.top();
                heap.pop();
            }
        }

        return res % MOD;
    }
};