feat: add solutions to lc problem: No.1383

No.1383.Maximum Performance of a Team

Author: yanglbme

solution/1300-1399/1383.Maximum Performance of a Team/README.md

@@ -51,22 +51,92 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：优先队列**
+
+本题是求“速度和”与“效率最小值”乘积的最大值。变量有两个，我们可以从大到小枚举 `efficiency[i]` 作为效率最小值，在所有效率大于等于 `efficiency[i]` 的工程师中选取不超过 k-1 个，让他们速度和最大。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
+        team = [(s, e) for s, e in zip(speed, efficiency)]
+        team.sort(key=lambda x: -x[1])
+        q = []
+        t = 0
+        ans = 0
+        mod = int(1e9) + 7
+        for s, e in team:
+            t += s
+            ans = max(ans, t * e)
+            heappush(q, s)
+            if len(q) >= k:
+                t -= heappop(q)
+        return ans % mod
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
+        int[][] team = new int[n][2];
+        for (int i = 0; i < n; ++i) {
+            team[i] = new int[]{speed[i], efficiency[i]};
+        }
+        Arrays.sort(team, (a, b) -> b[1] - a[1]);
+        PriorityQueue<Integer> q = new PriorityQueue<>((a, b) -> a - b);
+        long t = 0;
+        long ans = 0;
+        int mod = (int) 1e9 + 7;
+        for (int[] x : team) {
+            int s = x[0], e = x[1];
+            t += s;
+            ans = Math.max(ans, t * e);
+            q.offer(s);
+            if (q.size() >= k) {
+                t -= q.poll();
+            }
+        }
+        return (int) (ans % mod);
+    }
+}
+```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
+        vector<pair<int, int>> team;
+        for (int i = 0; i < n; ++i) team.push_back({-efficiency[i], speed[i]});
+        sort(team.begin(), team.end());
+        priority_queue<int, vector<int>, greater<int>> q;
+        long long ans = 0;
+        int mod = 1e9 + 7;
+        long long t = 0;
+        for (auto& x : team)
+        {
+            int s = x.second, e = -x.first;
+            t += s;
+            ans = max(ans, e * t);
+            q.push(s);
+            if (q.size() >= k)
+            {
+                t -= q.top();
+                q.pop();
+            }
+        }
+        return (int) (ans % mod);
+    }
+};
 ```
 
 ### **...**

solution/1300-1399/1383.Maximum Performance of a Team/README_EN.md

@@ -56,13 +56,79 @@ We have the maximum performance of the team by selecting engineer 2 (with speed=
 ### **Python3**
 
 ```python
-
+class Solution:
+    def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
+        team = [(s, e) for s, e in zip(speed, efficiency)]
+        team.sort(key=lambda x: -x[1])
+        q = []
+        t = 0
+        ans = 0
+        mod = int(1e9) + 7
+        for s, e in team:
+            t += s
+            ans = max(ans, t * e)
+            heappush(q, s)
+            if len(q) >= k:
+                t -= heappop(q)
+        return ans % mod
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
+        int[][] team = new int[n][2];
+        for (int i = 0; i < n; ++i) {
+            team[i] = new int[]{speed[i], efficiency[i]};
+        }
+        Arrays.sort(team, (a, b) -> b[1] - a[1]);
+        PriorityQueue<Integer> q = new PriorityQueue<>((a, b) -> a - b);
+        long t = 0;
+        long ans = 0;
+        int mod = (int) 1e9 + 7;
+        for (int[] x : team) {
+            int s = x[0], e = x[1];
+            t += s;
+            ans = Math.max(ans, t * e);
+            q.offer(s);
+            if (q.size() >= k) {
+                t -= q.poll();
+            }
+        }
+        return (int) (ans % mod);
+    }
+}
+```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
+        vector<pair<int, int>> team;
+        for (int i = 0; i < n; ++i) team.push_back({-efficiency[i], speed[i]});
+        sort(team.begin(), team.end());
+        priority_queue<int, vector<int>, greater<int>> q;
+        long long ans = 0;
+        int mod = 1e9 + 7;
+        long long t = 0;
+        for (auto& x : team)
+        {
+            int s = x.second, e = -x.first;
+            t += s;
+            ans = max(ans, e * t);
+            q.push(s);
+            if (q.size() >= k)
+            {
+                t -= q.top();
+                q.pop();
+            }
+        }
+        return (int) (ans % mod);
+    }
+};
 ```
 
 ### **...**

solution/1300-1399/1383.Maximum Performance of a Team/Solution.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
+        vector<pair<int, int>> team;
+        for (int i = 0; i < n; ++i) team.push_back({-efficiency[i], speed[i]});
+        sort(team.begin(), team.end());
+        priority_queue<int, vector<int>, greater<int>> q;
+        long long ans = 0;
+        int mod = 1e9 + 7;
+        long long t = 0;
+        for (auto& x : team)
+        {
+            int s = x.second, e = -x.first;
+            t += s;
+            ans = max(ans, e * t);
+            q.push(s);
+            if (q.size() >= k)
+            {
+                t -= q.top();
+                q.pop();
+            }
+        }
+        return (int) (ans % mod);
+    }
+};

solution/1300-1399/1383.Maximum Performance of a Team/Solution.java

@@ -0,0 +1,23 @@
+class Solution {
+    public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
+        int[][] team = new int[n][2];
+        for (int i = 0; i < n; ++i) {
+            team[i] = new int[]{speed[i], efficiency[i]};
+        }
+        Arrays.sort(team, (a, b) -> b[1] - a[1]);
+        PriorityQueue<Integer> q = new PriorityQueue<>((a, b) -> a - b);
+        long t = 0;
+        long ans = 0;
+        int mod = (int) 1e9 + 7;
+        for (int[] x : team) {
+            int s = x[0], e = x[1];
+            t += s;
+            ans = Math.max(ans, t * e);
+            q.offer(s);
+            if (q.size() >= k) {
+                t -= q.poll();
+            }
+        }
+        return (int) (ans % mod);
+    }
+}

solution/1300-1399/1383.Maximum Performance of a Team/Solution.py

@@ -0,0 +1,15 @@
+class Solution:
+    def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
+        team = [(s, e) for s, e in zip(speed, efficiency)]
+        team.sort(key=lambda x: -x[1])
+        q = []
+        t = 0
+        ans = 0
+        mod = int(1e9) + 7
+        for s, e in team:
+            t += s
+            ans = max(ans, t * e)
+            heappush(q, s)
+            if len(q) >= k:
+                t -= heappop(q)
+        return ans % mod

solution/1300-1399/1386.Cinema Seat Allocation/README.md

@@ -60,7 +60,7 @@
 
 哈希表中没有出现的行，每行可坐 2 个 4 人家庭，即 `(n - len(m)) << 1`。
 
-遍历哈希表中出现的行，依次尝试 1234, 5678, 3456 这几个连续座位（注意这里下标从 0 开始）是否均没被预定，是则累加答案，并且将此连续作为置为已预定。
+遍历哈希表中出现的行，依次贪心尝试 1234, 5678, 3456 这几个连续座位（注意这里下标从 0 开始）是否均没被预定，是则累加答案，并且将此连续座位置为已预定。
 
 <!-- tabs:start -->