Add solution #1383

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,267 LeetCode solutions in JavaScript
+# 1,268 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1054,6 +1054,7 @@
 1380|[Lucky Numbers in a Matrix](./solutions/1380-lucky-numbers-in-a-matrix.js)|Easy|
 1381|[Design a Stack With Increment Operation](./solutions/1381-design-a-stack-with-increment-operation.js)|Medium|
 1382|[Balance a Binary Search Tree](./solutions/1382-balance-a-binary-search-tree.js)|Medium|
+1383|[Maximum Performance of a Team](./solutions/1383-maximum-performance-of-a-team.js)|Hard|
 1389|[Create Target Array in the Given Order](./solutions/1389-create-target-array-in-the-given-order.js)|Easy|
 1400|[Construct K Palindrome Strings](./solutions/1400-construct-k-palindrome-strings.js)|Medium|
 1402|[Reducing Dishes](./solutions/1402-reducing-dishes.js)|Hard|

solutions/1383-maximum-performance-of-a-team.js

@@ -0,0 +1,79 @@
+/**
+ * 1383. Maximum Performance of a Team
+ * https://leetcode.com/problems/maximum-performance-of-a-team/
+ * Difficulty: Hard
+ *
+ * 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 ith 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 109 + 7.
+ */
+
+/**
+ * @param {number} n
+ * @param {number[]} speed
+ * @param {number[]} efficiency
+ * @param {number} k
+ * @return {number}
+ */
+var maxPerformance = function(n, speed, efficiency, k) {
+  const engineers = Array.from({ length: n }, (_, i) => [efficiency[i], speed[i]])
+    .sort((a, b) => b[0] - a[0]);
+  const speedHeap = [];
+  let totalSpeed = 0n;
+  let maxPerf = 0n;
+  const MOD = 1000000007n;
+
+  function insertSpeed(val) {
+    speedHeap.push(val);
+    let i = speedHeap.length - 1;
+    while (i > 0) {
+      const parent = Math.floor((i - 1) / 2);
+      if (speedHeap[parent] <= speedHeap[i]) break;
+      [speedHeap[i], speedHeap[parent]] = [speedHeap[parent], speedHeap[i]];
+      i = parent;
+    }
+  }
+
+  function removeMinSpeed() {
+    const min = speedHeap[0];
+    speedHeap[0] = speedHeap.pop();
+    let i = 0;
+    while (true) {
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      let smallest = i;
+      if (left < speedHeap.length && speedHeap[left] < speedHeap[smallest]) {
+        smallest = left;
+      }
+      if (right < speedHeap.length && speedHeap[right] < speedHeap[smallest]) {
+        smallest = right;
+      }
+      if (smallest === i) break;
+      [speedHeap[i], speedHeap[smallest]] = [speedHeap[smallest], speedHeap[i]];
+      i = smallest;
+    }
+    return min;
+  }
+
+  for (const [eff, spd] of engineers) {
+    insertSpeed(spd);
+    totalSpeed += BigInt(spd);
+
+    if (speedHeap.length > k) {
+      totalSpeed -= BigInt(removeMinSpeed());
+    }
+
+    maxPerf = maxPerf > totalSpeed * BigInt(eff) ? maxPerf : totalSpeed * BigInt(eff);
+  }
+
+  return Number(maxPerf % MOD);
+};