Add solution #1681

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,470 LeetCode solutions in JavaScript
+# 1,471 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1295,6 +1295,7 @@
 1678|[Goal Parser Interpretation](./solutions/1678-goal-parser-interpretation.js)|Easy|
 1679|[Max Number of K-Sum Pairs](./solutions/1679-max-number-of-k-sum-pairs.js)|Medium|
 1680|[Concatenation of Consecutive Binary Numbers](./solutions/1680-concatenation-of-consecutive-binary-numbers.js)|Medium|
+1681|[Minimum Incompatibility](./solutions/1681-minimum-incompatibility.js)|Hard|
 1716|[Calculate Money in Leetcode Bank](./solutions/1716-calculate-money-in-leetcode-bank.js)|Easy|
 1718|[Construct the Lexicographically Largest Valid Sequence](./solutions/1718-construct-the-lexicographically-largest-valid-sequence.js)|Medium|
 1726|[Tuple with Same Product](./solutions/1726-tuple-with-same-product.js)|Medium|

solutions/1681-minimum-incompatibility.js

@@ -0,0 +1,65 @@
+/**
+ * 1681. Minimum Incompatibility
+ * https://leetcode.com/problems/minimum-incompatibility/
+ * Difficulty: Hard
+ *
+ * You are given an integer array nums and an integer k. You are asked to distribute this array
+ * into k subsets of equal size such that there are no two equal elements in the same subset.
+ *
+ * A subset's incompatibility is the difference between the maximum and minimum elements in that
+ * array.
+ *
+ * Return the minimum possible sum of incompatibilities of the k subsets after distributing the
+ * array optimally, or return -1 if it is not possible.
+ *
+ * A subset is a group integers that appear in the array with no particular order.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minimumIncompatibility = function(nums, k) {
+  const n = nums.length;
+  const subsetSize = n / k;
+  const freq = new Array(n + 1).fill(0);
+  for (const num of nums) {
+    freq[num]++;
+    if (freq[num] > k) return -1;
+  }
+
+  nums.sort((a, b) => a - b);
+  const subsetValues = new Map();
+
+  computeSubsets(0, 0, 0, 0, 0, []);
+
+  const dp = new Array(1 << n).fill(Infinity);
+  dp[0] = 0;
+
+  for (let mask = 0; mask < (1 << n); mask++) {
+    if (dp[mask] === Infinity) continue;
+    for (const [subsetMask, value] of subsetValues) {
+      if ((mask & subsetMask) === 0) {
+        const newMask = mask | subsetMask;
+        dp[newMask] = Math.min(dp[newMask], dp[mask] + value);
+      }
+    }
+  }
+
+  return dp[(1 << n) - 1] === Infinity ? -1 : dp[(1 << n) - 1];
+
+  function computeSubsets(mask, index, count, minVal, maxVal, selected) {
+    if (count === subsetSize) {
+      subsetValues.set(mask, maxVal - minVal);
+      return;
+    }
+    if (index >= n || n - index < subsetSize - count) return;
+
+    computeSubsets(mask, index + 1, count, minVal, maxVal, selected);
+    if (!selected.includes(nums[index])) {
+      computeSubsets(mask | (1 << index), index + 1, count + 1,
+        count === 0 ? nums[index] : minVal, nums[index], [...selected, nums[index]]);
+    }
+  }
+};