Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Break down a hard problem into reliable checkpoints, edge-case handling, and complexity trade-offs.
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 the 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 will end the game with the same score.
Example 1:
Input: stoneValue = [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: stoneValue = [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. In 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. In 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: stoneValue = [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.
Constraints:
1 <= stoneValue.length <= 5 * 104-1000 <= stoneValue[i] <= 1000Problem summary: 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 the 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 will end the game with the same score.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array · Math · Dynamic Programming
[1,2,3,7]
[1,2,3,-9]
[1,2,3,6]
stone-game-v)stone-game-vi)stone-game-vii)stone-game-viii)stone-game-ix)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1406: Stone Game III
class Solution {
private int[] stoneValue;
private Integer[] f;
private int n;
public String stoneGameIII(int[] stoneValue) {
n = stoneValue.length;
f = new Integer[n];
this.stoneValue = stoneValue;
int ans = dfs(0);
if (ans == 0) {
return "Tie";
}
return ans > 0 ? "Alice" : "Bob";
}
private int dfs(int i) {
if (i >= n) {
return 0;
}
if (f[i] != null) {
return f[i];
}
int ans = -(1 << 30);
int s = 0;
for (int 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;
}
}
// Accepted solution for LeetCode #1406: Stone Game III
func stoneGameIII(stoneValue []int) string {
n := len(stoneValue)
f := make([]int, n)
const inf = 1 << 30
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]
}
ans, s := -(1 << 30), 0
for j := 0; j < 3 && i+j < n; j++ {
s += stoneValue[i+j]
ans = max(ans, s-dfs(i+j+1))
}
f[i] = ans
return ans
}
ans := dfs(0)
if ans == 0 {
return "Tie"
}
if ans > 0 {
return "Alice"
}
return "Bob"
}
# Accepted solution for LeetCode #1406: Stone Game III
class Solution:
def stoneGameIII(self, stoneValue: List[int]) -> str:
@cache
def dfs(i: int) -> int:
if i >= n:
return 0
ans, s = -inf, 0
for j in range(3):
if i + j >= n:
break
s += stoneValue[i + j]
ans = max(ans, s - dfs(i + j + 1))
return ans
n = len(stoneValue)
ans = dfs(0)
if ans == 0:
return 'Tie'
return 'Alice' if ans > 0 else 'Bob'
// Accepted solution for LeetCode #1406: Stone Game III
struct Solution;
use std::cmp::Ordering::*;
use std::collections::HashMap;
impl Solution {
fn stone_game_iii(values: Vec<i32>) -> String {
let n = values.len();
let mut memo: HashMap<usize, i32> = HashMap::new();
match Self::dp(0, &mut memo, &values, n).cmp(&0) {
Equal => "Tie".to_string(),
Greater => "Alice".to_string(),
Less => "Bob".to_string(),
}
}
fn dp(start: usize, memo: &mut HashMap<usize, i32>, values: &[i32], n: usize) -> i32 {
if let Some(&res) = memo.get(&start) {
return res;
}
let res = if start == n {
0
} else {
let mut sum = 0;
let mut max = std::i32::MIN;
for i in start..(start + 3).min(n) {
sum += values[i];
max = max.max(sum - Self::dp(i + 1, memo, values, n));
}
max
};
memo.insert(start, res);
res
}
}
#[test]
fn test() {
let values = vec![1, 2, 3, 7];
let res = "Bob".to_string();
assert_eq!(Solution::stone_game_iii(values), res);
let values = vec![1, 2, 3, 6];
let res = "Tie".to_string();
assert_eq!(Solution::stone_game_iii(values), res);
let values = vec![1, 2, 3, -1, -2, -3, 7];
let res = "Alice".to_string();
assert_eq!(Solution::stone_game_iii(values), res);
let values = vec![-1, -2, -3];
let res = "Tie".to_string();
assert_eq!(Solution::stone_game_iii(values), res);
}
// Accepted solution for LeetCode #1406: Stone Game III
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';
}
Use this to step through a reusable interview workflow for this problem.
Pure recursion explores every possible choice at each step. With two choices per state (take or skip), the decision tree has 2ⁿ leaves. The recursion stack uses O(n) space. Many subproblems are recomputed exponentially many times.
Each cell in the DP table is computed exactly once from previously solved subproblems. The table dimensions determine both time and space. Look for the state variables — each unique combination of state values is one cell. Often a rolling array can reduce space by one dimension.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Wrong move: Temporary multiplications exceed integer bounds.
Usually fails on: Large inputs wrap around unexpectedly.
Fix: Use wider types, modular arithmetic, or rearranged operations.
Wrong move: An incomplete state merges distinct subproblems and caches incorrect answers.
Usually fails on: Correctness breaks on cases that differ only in hidden state.
Fix: Define state so each unique subproblem maps to one DP cell.