Add solution #2333

Author: JoshCrozier

README.md

@@ -2117,6 +2117,7 @@
 2330|[Valid Palindrome IV](./solutions/2330-valid-palindrome-iv.js)|Medium|
 2331|[Evaluate Boolean Binary Tree](./solutions/2331-evaluate-boolean-binary-tree.js)|Easy|
 2332|[The Latest Time to Catch a Bus](./solutions/2332-the-latest-time-to-catch-a-bus.js)|Medium|
+2333|[Minimum Sum of Squared Difference](./solutions/2333-minimum-sum-of-squared-difference.js)|Medium|
 2334|[Subarray With Elements Greater Than Varying Threshold](./solutions/2334-subarray-with-elements-greater-than-varying-threshold.js)|Hard|
 2335|[Minimum Amount of Time to Fill Cups](./solutions/2335-minimum-amount-of-time-to-fill-cups.js)|Easy|
 2336|[Smallest Number in Infinite Set](./solutions/2336-smallest-number-in-infinite-set.js)|Medium|

solutions/2333-minimum-sum-of-squared-difference.js

@@ -0,0 +1,84 @@
+/**
+ * 2333. Minimum Sum of Squared Difference
+ * https://leetcode.com/problems/minimum-sum-of-squared-difference/
+ * Difficulty: Medium
+ *
+ * You are given two positive 0-indexed integer arrays nums1 and nums2, both of length n.
+ *
+ * The sum of squared difference of arrays nums1 and nums2 is defined as the sum of
+ * (nums1[i] - nums2[i])2 for each 0 <= i < n.
+ *
+ * You are also given two positive integers k1 and k2. You can modify any of the elements
+ * of nums1 by +1 or -1 at most k1 times. Similarly, you can modify any of the elements
+ * of nums2 by +1 or -1 at most k2 times.
+ *
+ * Return the minimum sum of squared difference after modifying array nums1 at most k1
+ * times and modifying array nums2 at most k2 times.
+ *
+ * Note: You are allowed to modify the array elements to become negative integers.
+ */
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k1
+ * @param {number} k2
+ * @return {number}
+ */
+var minSumSquareDiff = function(nums1, nums2, k1, k2) {
+  const n = nums1.length;
+  const frequencyMap = new Map();
+
+  for (let i = 0; i < n; i++) {
+    const diff = Math.abs(nums1[i] - nums2[i]);
+    frequencyMap.set(diff, (frequencyMap.get(diff) || 0) + 1);
+  }
+
+  let totalMoves = k1 + k2;
+  const maxHeap = new PriorityQueue((a, b) => b[0] - a[0]);
+
+  for (const [value, count] of frequencyMap) {
+    if (value === 0) continue;
+    maxHeap.enqueue([value, count]);
+  }
+
+  while (!maxHeap.isEmpty() && totalMoves > 0) {
+    const [value, count] = maxHeap.dequeue();
+
+    if (maxHeap.isEmpty()) {
+      const moves = Math.min(totalMoves, count);
+      totalMoves -= moves;
+      const remainingCount = count - moves;
+
+      if (value - 1 > 0) {
+        maxHeap.enqueue([value - 1, moves]);
+      }
+      if (remainingCount > 0) {
+        maxHeap.enqueue([value, remainingCount]);
+      }
+    } else {
+      const moves = Math.min(totalMoves, count);
+      totalMoves -= moves;
+      const remainingCount = count - moves;
+
+      if (remainingCount > 0) {
+        maxHeap.enqueue([value, remainingCount]);
+      }
+
+      if (!maxHeap.isEmpty() && maxHeap.front()[0] === value - 1) {
+        const [nextValue, nextCount] = maxHeap.dequeue();
+        maxHeap.enqueue([nextValue, nextCount + moves]);
+      } else if (value - 1 > 0) {
+        maxHeap.enqueue([value - 1, moves]);
+      }
+    }
+  }
+
+  let result = 0;
+  while (!maxHeap.isEmpty()) {
+    const [value, count] = maxHeap.dequeue();
+    result += value * value * count;
+  }
+
+  return result;
+};