Add solution #1000

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,078 LeetCode solutions in JavaScript
+# 1,079 LeetCode solutions in JavaScript
 
 [https://leetcode.com/](https://leetcode.com/)
 
@@ -808,6 +808,7 @@
 997|[Find the Town Judge](./solutions/0997-find-the-town-judge.js)|Easy|
 998|[Maximum Binary Tree II](./solutions/0998-maximum-binary-tree-ii.js)|Medium|
 999|[Available Captures for Rook](./solutions/0999-available-captures-for-rook.js)|Easy|
+1000|[Minimum Cost to Merge Stones](./solutions/1000-minimum-cost-to-merge-stones.js)|Hard|
 1002|[Find Common Characters](./solutions/1002-find-common-characters.js)|Easy|
 1004|[Max Consecutive Ones III](./solutions/1004-max-consecutive-ones-iii.js)|Medium|
 1005|[Maximize Sum Of Array After K Negations](./solutions/1005-maximize-sum-of-array-after-k-negations.js)|Easy|

solutions/1000-minimum-cost-to-merge-stones.js

@@ -0,0 +1,50 @@
+/**
+ * 1000. Minimum Cost to Merge Stones
+ * https://leetcode.com/problems/minimum-cost-to-merge-stones/
+ * Difficulty: Hard
+ *
+ * There are n piles of stones arranged in a row. The ith pile has stones[i] stones.
+ *
+ * A move consists of merging exactly k consecutive piles into one pile, and the cost of
+ * this move is equal to the total number of stones in these k piles.
+ *
+ * Return the minimum cost to merge all piles of stones into one pile. If it is impossible,
+ * return -1.
+ */
+
+/**
+ * @param {number[]} stones
+ * @param {number} k
+ * @return {number}
+ */
+var mergeStones = function(stones, k) {
+  const n = stones.length;
+  if ((n - 1) % (k - 1) !== 0) return -1;
+
+  const prefixSums = new Array(n + 1).fill(0);
+  for (let i = 0; i < n; i++) {
+    prefixSums[i + 1] = prefixSums[i] + stones[i];
+  }
+
+  const dp = new Array(n).fill().map(() => new Array(n).fill(0));
+
+  for (let len = k; len <= n; len++) {
+    for (let start = 0; start + len <= n; start++) {
+      const end = start + len - 1;
+      dp[start][end] = Infinity;
+
+      for (let mid = start; mid < end; mid += k - 1) {
+        dp[start][end] = Math.min(
+          dp[start][end],
+          dp[start][mid] + dp[mid + 1][end]
+        );
+      }
+
+      if ((len - 1) % (k - 1) === 0) {
+        dp[start][end] += prefixSums[end + 1] - prefixSums[start];
+      }
+    }
+  }
+
+  return dp[0][n - 1];
+};