##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1406.html

# 1406. Stone Game III (Hard)

Alice and Bob continue their games with piles of stones. There are several stones arranged in a row, and each stone has an associated value which is an integer given in the array stoneValue.

Alice and Bob take turns, with Alice starting first. On each player's turn, that player can take 1, 2 or 3 stones from the first remaining stones in the row.

The score of each player is the sum of values of the stones taken. The score of each player is 0 initially.

The objective of the game is to end with the highest score, and the winner is the player with the highest score and there could be a tie. The game continues until all the stones have been taken.

Assume Alice and Bob play optimally.

Return "Alice" if Alice will win, "Bob" if Bob will win or "Tie" if they end the game with the same score.

Example 1:

Input: values = [1,2,3,7]
Output: "Bob"
Explanation: Alice will always lose. Her best move will be to take three piles and the score become 6. Now the score of Bob is 7 and Bob wins.


Example 2:

Input: values = [1,2,3,-9]
Output: "Alice"
Explanation: Alice must choose all the three piles at the first move to win and leave Bob with negative score.
If Alice chooses one pile her score will be 1 and the next move Bob's score becomes 5. The next move Alice will take the pile with value = -9 and lose.
If Alice chooses two piles her score will be 3 and the next move Bob's score becomes 3. The next move Alice will take the pile with value = -9 and also lose.
Remember that both play optimally so here Alice will choose the scenario that makes her win.


Example 3:

Input: values = [1,2,3,6]
Output: "Tie"
Explanation: Alice cannot win this game. She can end the game in a draw if she decided to choose all the first three piles, otherwise she will lose.


Example 4:

Input: values = [1,2,3,-1,-2,-3,7]
Output: "Alice"


Example 5:

Input: values = [-1,-2,-3]
Output: "Tie"


Constraints:

• 1 <= values.length <= 50000
• -1000 <= values[i] <= 1000

Related Topics:
Dynamic Programming

## Solution 1. DP

This problem is similar to 1140. Stone Game II.

For each round, my best option in this turn must be the worst option of the other player in the next turn.

Let dp[i] be the best result the current player can get at this ith element.

dp[i] = max(
A[i] - dp[i+1],                    // If I only pick one
A[i] + A[i+1] - dp[i+2]            // If I pick two
A[i] + A[i+1] + A[i+2] - dp[i+3]   // If I pick three
)


So we can compute dp[i] from the end of the array. dp[i] = 0 if i >= N.

// OJ: https://leetcode.com/problems/stone-game-iii/
// Time: O(N)
// Space: O(N)
class Solution {
public:
string stoneGameIII(vector<int>& A) {
int N = A.size();
vector<int> dp(N + 1, INT_MIN);
dp[N] = 0;
for (int i = N - 1; i >= 0; --i) {
int s = 0;
for (int j = 0; j < 3 && i + j < N; ++j) dp[i] = max(dp[i], -dp[i + j + 1] + (s += A[i + j]));
}
return dp[0] > 0 ? "Alice" : (dp[0] < 0 ? "Bob" : "Tie");
}
};


## Solution 2. DP + Space Optimization

Since dp[i] is only dependent to the next 3 dp values. We can reduce the dp array side from N to 4.

// OJ: https://leetcode.com/problems/stone-game-iii/
// Time: O(N)
// Space: O(1)
class Solution {
public:
string stoneGameIII(vector<int>& A) {
int N = A.size(), dp[4] = {};
for (int i = N - 1; i >= 0; --i) {
int s = 0;
dp[i % 4] = INT_MIN;
for (int j = 0; j < 3 && i + j < N; ++j) dp[i % 4] = max(dp[i % 4], -dp[(i + j + 1) % 4] + (s += A[i + j]));
}
return dp[0] > 0 ? "Alice" : (dp[0] < 0 ? "Bob" : "Tie");
}
};

• class Solution {
public String stoneGameIII(int[] stoneValue) {
int length = stoneValue.length;
int[] dp = new int[length + 1];
Arrays.fill(dp, Integer.MIN_VALUE);
dp[length] = 0;
for (int i = length - 1; i >= 0; i--) {
int sum = 0;
int max = Math.min(i + 2, length - 1);
for (int j = i; j <= max; j++) {
sum += stoneValue[j];
dp[i] = Math.max(dp[i], sum - dp[j + 1]);
}
}
if (dp[0] > 0)
return "Alice";
else if (dp[0] < 0)
return "Bob";
else
return "Tie";
}
}

############

class Solution {
private int n;
private int[] s;
private Integer[] f;

public String stoneGameIII(int[] stoneValue) {
n = stoneValue.length;
s = new int[n + 1];
f = new Integer[n];
for (int i = 1; i <= n; ++i) {
s[i] = s[i - 1] + stoneValue[i - 1];
}
int a = dfs(0);
int b = s[n] - a;
return a == b ? "Tie" : a > b ? "Alice" : "Bob";
}

private int dfs(int i) {
if (i >= n) {
return 0;
}
if (f[i] != null) {
return f[i];
}
int t = 1 << 30;
for (int j = 1; j < 4; ++j) {
t = Math.min(t, dfs(i + j));
}
f[i] = s[n] - s[i] - t;
return f[i];
}
}

• // OJ: https://leetcode.com/problems/stone-game-iii/
// Time: O(N)
// Space: O(N)
class Solution {
public:
string stoneGameIII(vector<int>& A) {
int N = A.size();
vector<int> dp(N + 1, INT_MIN);
dp[N] = 0;
for (int i = N - 1; i >= 0; --i) {
int s = 0;
for (int j = 0; j < 3 && i + j < N; ++j) dp[i] = max(dp[i], -dp[i + j + 1] + (s += A[i + j]));
}
return dp[0] > 0 ? "Alice" : (dp[0] < 0 ? "Bob" : "Tie");
}
};

• class Solution:
def stoneGameIII(self, stoneValue: List[int]) -> str:
@cache
def dfs(i: int) -> int:
if i >= len(stoneValue):
return 0
t = min(dfs(i + j) for j in range(1, 4))
return s[-1] - s[i] - t

s = list(accumulate(stoneValue, initial=0))
a = dfs(0)
b = s[-1] - a
if a == b:
return 'Tie'
return 'Alice' if a > b else 'Bob'


• func stoneGameIII(stoneValue []int) string {
n := len(stoneValue)
s := make([]int, n+1)
for i, x := range stoneValue {
s[i+1] = s[i] + x
}
const inf = 1 << 30
f := make([]int, n)
for i := range f {
f[i] = inf
}
var dfs func(int) int
dfs = func(i int) int {
if i >= n {
return 0
}
if f[i] != inf {
return f[i]
}
t := inf
for j := 1; j <= 3; j++ {
t = min(t, dfs(i+j))
}
f[i] = s[n] - s[i] - t
return f[i]
}
a := dfs(0)
b := s[n] - a
if a == b {
return "Tie"
}
if a > b {
return "Alice"
}
return "Bob"
}

func min(a, b int) int {
if a < b {
return a
}
return b
}

• function stoneGameIII(stoneValue: number[]): string {
const n = stoneValue.length;
const inf = 1 << 30;
const f: number[] = new Array(n).fill(inf);
const dfs = (i: number): number => {
if (i >= n) {
return 0;
}
if (f[i] !== inf) {
return f[i];
}
let ans = -inf;
let s = 0;
for (let j = 0; j < 3 && i + j < n; ++j) {
s += stoneValue[i + j];
ans = Math.max(ans, s - dfs(i + j + 1));
}
return (f[i] = ans);
};
const ans = dfs(0);
if (ans === 0) {
return 'Tie';
}
return ans > 0 ? 'Alice' : 'Bob';
}