feat: solve No.1140

Author: BaffinLee

1101-1200/1140. Stone Game II.md

@@ -0,0 +1,87 @@
+# 1140. Stone Game II
+
+- Difficulty: Medium.
+- Related Topics: Array, Math, Dynamic Programming, Prefix Sum, Game Theory.
+- Similar Questions: Stone Game V, Stone Game VI, Stone Game VII, Stone Game VIII, Stone Game IX.
+
+## Problem
+
+Alice and Bob continue their games with piles of stones.  There are a number of piles **arranged in a row**, and each pile has a positive integer number of stones `piles[i]`.  The objective of the game is to end with the most stones. 
+
+Alice and Bob take turns, with Alice starting first.  Initially, `M = 1`.
+
+On each player's turn, that player can take **all the stones** in the **first** `X` remaining piles, where `1 <= X <= 2M`.  Then, we set `M = max(M, X)`.
+
+The game continues until all the stones have been taken.
+
+Assuming Alice and Bob play optimally, return the maximum number of stones Alice can get.
+
+ 
+Example 1:
+
+```
+Input: piles = [2,7,9,4,4]
+Output: 10
+Explanation:  If Alice takes one pile at the beginning, Bob takes two piles, then Alice takes 2 piles again. Alice can get 2 + 4 + 4 = 10 piles in total. If Alice takes two piles at the beginning, then Bob can take all three piles left. In this case, Alice get 2 + 7 = 9 piles in total. So we return 10 since it's larger. 
+```
+
+Example 2:
+
+```
+Input: piles = [1,2,3,4,5,100]
+Output: 104
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= piles.length <= 100`
+	
+- `1 <= piles[i] <= 104`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} piles
+ * @return {number}
+ */
+var stoneGameII = function(piles) {
+    var dp = Array(piles.length).fill(0).map(() => ({}));
+    var suffixSum = Array(piles.length);
+    for (var i = piles.length - 1; i >= 0; i--) {
+        suffixSum[i] = (suffixSum[i + 1] || 0) + piles[i];
+    }
+    return helper(piles, 0, 1, dp, suffixSum);
+};
+
+var helper = function(piles, i, M, dp, suffixSum) {
+    if (dp[i][M]) return dp[i][M];
+    var res = 0;
+    var sum = 0;
+    for (var j = 0; j < 2 * M && i + j < piles.length; j++) {
+        sum += piles[i + j];
+        res = Math.max(
+            res,
+            i + j + 1 === piles.length
+                ? sum
+                : sum + suffixSum[i + j + 1] - helper(piles, i + j + 1, Math.max(M, j + 1), dp, suffixSum)
+        );
+    }
+    dp[i][M] = res;
+    return res;
+}
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n ^ 3).
+* Space complexity : O(n ^ 2).