Add solution #1959

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,653 LeetCode solutions in JavaScript
+# 1,654 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1504,6 +1504,7 @@
 1955|[Count Number of Special Subsequences](./solutions/1955-count-number-of-special-subsequences.js)|Hard|
 1957|[Delete Characters to Make Fancy String](./solutions/1957-delete-characters-to-make-fancy-string.js)|Easy|
 1958|[Check if Move is Legal](./solutions/1958-check-if-move-is-legal.js)|Medium|
+1959|[Minimum Total Space Wasted With K Resizing Operations](./solutions/1959-minimum-total-space-wasted-with-k-resizing-operations.js)|Medium|
 1976|[Number of Ways to Arrive at Destination](./solutions/1976-number-of-ways-to-arrive-at-destination.js)|Medium|
 1980|[Find Unique Binary String](./solutions/1980-find-unique-binary-string.js)|Medium|
 1985|[Find the Kth Largest Integer in the Array](./solutions/1985-find-the-kth-largest-integer-in-the-array.js)|Medium|

solutions/1959-minimum-total-space-wasted-with-k-resizing-operations.js

@@ -0,0 +1,54 @@
+/**
+ * 1959. Minimum Total Space Wasted With K Resizing Operations
+ * https://leetcode.com/problems/minimum-total-space-wasted-with-k-resizing-operations/
+ * Difficulty: Medium
+ *
+ * You are currently designing a dynamic array. You are given a 0-indexed integer array nums,
+ * where nums[i] is the number of elements that will be in the array at time i. In addition,
+ * you are given an integer k, the maximum number of times you can resize the array (to any size).
+ *
+ * The size of the array at time t, sizet, must be at least nums[t] because there needs to be
+ * enough space in the array to hold all the elements. The space wasted at time t is defined
+ * as sizet - nums[t], and the total space wasted is the sum of the space wasted across every
+ * time t where 0 <= t < nums.length.
+ *
+ * Return the minimum total space wasted if you can resize the array at most k times.
+ *
+ * Note: The array can have any size at the start and does not count towards the number of
+ * resizing operations.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minSpaceWastedKResizing = function(nums, k) {
+  const n = nums.length;
+  const dp = new Array(n + 1).fill().map(() => new Array(k + 2).fill(Infinity));
+  dp[0][0] = 0;
+
+  for (let i = 1; i <= n; i++) {
+    let maxVal = 0;
+    let sum = 0;
+
+    for (let j = i; j > 0; j--) {
+      maxVal = Math.max(maxVal, nums[j - 1]);
+      sum += nums[j - 1];
+      const waste = maxVal * (i - j + 1) - sum;
+
+      for (let resizes = 0; resizes <= k; resizes++) {
+        if (dp[j - 1][resizes] !== Infinity) {
+          dp[i][resizes + 1] = Math.min(dp[i][resizes + 1], dp[j - 1][resizes] + waste);
+        }
+      }
+    }
+  }
+
+  let result = Infinity;
+  for (let resizes = 1; resizes <= k + 1; resizes++) {
+    result = Math.min(result, dp[n][resizes]);
+  }
+
+  return result;
+};