Add solution #3422

JoshCrozier · JoshCrozier · commit 94520479d903 · 2025-07-23T23:50:43.000-05:00
diff --git a/README.md b/README.md
@@ -2690,6 +2690,7 @@
 3405|[Count the Number of Arrays with K Matching Adjacent Elements](./solutions/3405-count-the-number-of-arrays-with-k-matching-adjacent-elements.js)|Hard|
 3406|[Find the Lexicographically Largest String From the Box II](./solutions/3406-find-the-lexicographically-largest-string-from-the-box-ii.js)|Hard|
 3416|[Subsequences with a Unique Middle Mode II](./solutions/3416-subsequences-with-a-unique-middle-mode-ii.js)|Hard|
+3422|[Minimum Operations to Make Subarray Elements Equal](./solutions/3422-minimum-operations-to-make-subarray-elements-equal.js)|Medium|
 3423|[Maximum Difference Between Adjacent Elements in a Circular Array](./solutions/3423-maximum-difference-between-adjacent-elements-in-a-circular-array.js)|Easy|
 3439|[Reschedule Meetings for Maximum Free Time I](./solutions/3439-reschedule-meetings-for-maximum-free-time-i.js)|Medium|
 3440|[Reschedule Meetings for Maximum Free Time II](./solutions/3440-reschedule-meetings-for-maximum-free-time-ii.js)|Medium|
diff --git a/solutions/3422-minimum-operations-to-make-subarray-elements-equal.js b/solutions/3422-minimum-operations-to-make-subarray-elements-equal.js
@@ -0,0 +1,81 @@
+/**
+ * 3422. Minimum Operations to Make Subarray Elements Equal
+ * https://leetcode.com/problems/minimum-operations-to-make-subarray-elements-equal/
+ * Difficulty: Medium
+ *
+ * You are given an integer array nums and an integer k. You can perform the following operation
+ * any number of times:
+ * - Increase or decrease any element of nums by 1.
+ *
+ * Return the minimum number of operations required to ensure that at least one subarray of size
+ * k in nums has all elements equal.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minOperations = function(nums, k) {
+  const n = nums.length;
+  const minHeap = new PriorityQueue((a, b) => a[0] < b[0] ? -1 : 1);
+  const maxHeap = new PriorityQueue((a, b) => a[0] > b[0] ? -1 : 1);
+  const maxHeapSize = Math.ceil(k / 2);
+  const minHeapSize = k - maxHeapSize;
+
+  let total = 0;
+  for (let i = 0; i < k; i++) {
+    total += nums[i];
+    maxHeap.enqueue([nums[i], i]);
+  }
+
+  let minSum = 0;
+  const minHeapIndices = new Set();
+  for (let i = 0; i < minHeapSize; i++) {
+    const [num, idx] = maxHeap.dequeue();
+    minSum += num;
+    minHeap.enqueue([num, idx]);
+    minHeapIndices.add(idx);
+  }
+
+  let maxSum = total - minSum;
+  let median = maxHeap.front()[0];
+  let result = Math.abs(median * maxHeapSize - maxSum) + Math.abs(minSum - median * minHeapSize);
+
+  for (let i = k; i < n; i++) {
+    const num = nums[i];
+    const leftOut = i - k;
+    total += num - nums[leftOut];
+
+    while (!minHeap.isEmpty() && minHeap.front()[1] <= leftOut) minHeap.dequeue();
+    while (!maxHeap.isEmpty() && maxHeap.front()[1] <= leftOut) maxHeap.dequeue();
+
+    if (minHeapIndices.has(leftOut)) {
+      minHeapIndices.delete(leftOut);
+      minSum -= nums[leftOut];
+      maxHeap.enqueue([num, i]);
+      const [newNum, newIdx] = maxHeap.dequeue();
+      minSum += newNum;
+      minHeap.enqueue([newNum, newIdx]);
+      minHeapIndices.add(newIdx);
+    } else {
+      minHeap.enqueue([num, i]);
+      minSum += num;
+      minHeapIndices.add(i);
+      const [newNum, newIdx] = minHeap.dequeue();
+      minHeapIndices.delete(newIdx);
+      minSum -= newNum;
+      maxHeap.enqueue([newNum, newIdx]);
+    }
+
+    maxSum = total - minSum;
+    while (!maxHeap.isEmpty() && maxHeap.front()[1] <= leftOut) maxHeap.dequeue();
+    median = maxHeap.front()[0];
+    result = Math.min(
+      result,
+      Math.abs(median * maxHeapSize - maxSum) + Math.abs(minSum - median * minHeapSize)
+    );
+  }
+
+  return result;
+};
