LeetCode-Python-1383. 最大的团队表现值（堆 + 贪心）

公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 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

提示：

• 1 <= n <= 10^5
• speed.length == n
• efficiency.length == n
• 1 <= speed[i] <= 10^5
• 1 <= efficiency[i] <= 10^8
• 1 <= k <= n

思路：

当结果由两部分，speed_sum 和 min(effiency) 计算得来时，就比较麻烦，

如果我们能固定一部分，通过改变另一部分的值来计算结果，就会较为简单。

扫描二维码关注公众号，回复： 10216841 查看本文章

那选择固定哪一部分呢？

显然应该选择 min(effiency)， 因为一个团队里效率的最小值永远由效率最低的那个人决定，只要固定了这个人，无论其他的人怎么变，min(effiency）都不会改变。

所以我们不妨以每一个人的效率作为一个团队里的最小效率，来构建团队。

比如说，我们选择A的效率为最小效率，接着我们就可以在比A效率高的人里面选 K - 1个，来得到最大的 speed_sum。

找最大的speed_sum的过程等于经典的 TOPK 问题，可以由最小堆求解。

时间复杂度: O(NlogN + NlogK)

空间复杂度：O（N + K）

class Solution(object):
    def maxPerformance(self, n, speed, efficiency, k):
        """
        :type n: int
        :type speed: List[int]
        :type efficiency: List[int]
        :type k: int
        :rtype: int
        """
        from heapq import *
        combine = [(speed[i], efficiency[i]) for i in range(n)]
        combine = sorted(combine, key = lambda x: - x[1])
        res = 0
        MOD = 10 ** 9 + 7
        min_heap = []
        speed_sum = 0
        for i in range(n):
            s, e = combine[i]
            if len(min_heap) < k:
                heappush(min_heap, s)
                speed_sum += s
            else:
                if min_heap and min_heap[0] < s:
                    speed_sum = speed_sum - min_heap[0] + s
                    heappush(min_heap, s)
                    heappop(min_heap)
                    
            res = max(res, speed_sum * e)
        return res % MOD