Skip to content

877. Stone Game

Description

Alice and Bob play a game with piles of stones. There are an even 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. The total number of stones across all the piles is odd, so there are no ties.

Alice and Bob take turns, with Alice starting first. Each turn, a player takes the entire pile of stones either from the beginning or from the end of the row. This continues until there are no more piles left, at which point the person with the most stones wins.

Assuming Alice and Bob play optimally, return true if Alice wins the game, or false if Bob wins.

Β 

Example 1:

Input: piles = [5,3,4,5]
Output: true
Explanation: 
Alice starts first, and can only take the first 5 or the last 5.
Say she takes the first 5, so that the row becomes [3, 4, 5].
If Bob takes 3, then the board is [4, 5], and Alice takes 5 to win with 10 points.
If Bob takes the last 5, then the board is [3, 4], and Alice takes 4 to win with 9 points.
This demonstrated that taking the first 5 was a winning move for Alice, so we return true.

Example 2:

Input: piles = [3,7,2,3]
Output: true

Β 

Constraints:

  • 2 <= piles.length <= 500
  • piles.length is even.
  • 1 <= piles[i] <= 500
  • sum(piles[i]) is odd.

Solutions

We design a function \(dfs(i, j)\) that represents the maximum difference in the number of stones between the current player and the other player when considering piles from the \(i\)-th to the \(j\)-th. The answer is then \(dfs(0, n - 1) \gt 0\).

The function \(dfs(i, j)\) is computed as follows:

  • If \(i \gt j\), there are no stones left, so the current player cannot take any stones and the difference is \(0\), i.e., \(dfs(i, j) = 0\).
  • Otherwise, the current player has two choices: if they take the \(i\)-th pile, the difference between the current player and the other player is \(piles[i] - dfs(i + 1, j)\); if they take the \(j\)-th pile, the difference is \(piles[j] - dfs(i, j - 1)\). The current player will choose the option with the larger difference, so \(dfs(i, j) = \max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1))\).

Finally, we only need to check whether \(dfs(0, n - 1) \gt 0\).

To avoid redundant computation, we can use memoization: we use an array \(f\) to record all values of \(dfs(i, j)\), so that when the function is called again, we can directly retrieve the answer from \(f\) without recomputing.

The time complexity is \(O(n^2)\) and the space complexity is \(O(n^2)\), where \(n\) is the number of stone piles.

1
2
3
4
5
6
7
8
9
class Solution:
    def stoneGame(self, piles: List[int]) -> bool:
        @cache
        def dfs(i: int, j: int) -> int:
            if i > j:
                return 0
            return max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1))

        return dfs(0, len(piles) - 1) > 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    private int[] piles;
    private int[][] f;

    public boolean stoneGame(int[] piles) {
        this.piles = piles;
        int n = piles.length;
        f = new int[n][n];
        return dfs(0, n - 1) > 0;
    }

    private int dfs(int i, int j) {
        if (i > j) {
            return 0;
        }
        if (f[i][j] != 0) {
            return f[i][j];
        }
        return f[i][j] = Math.max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
class Solution {
public:
    bool stoneGame(vector<int>& piles) {
        int n = piles.size();
        int f[n][n];
        memset(f, 0, sizeof(f));
        auto dfs = [&](this auto&& dfs, int i, int j) -> int {
            if (i > j) {
                return 0;
            }
            if (f[i][j]) {
                return f[i][j];
            }
            return f[i][j] = max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1));
        };
        return dfs(0, n - 1) > 0;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
func stoneGame(piles []int) bool {
    n := len(piles)
    f := make([][]int, n)
    for i := range f {
        f[i] = make([]int, n)
    }
    var dfs func(i, j int) int
    dfs = func(i, j int) int {
        if i > j {
            return 0
        }
        if f[i][j] == 0 {
            f[i][j] = max(piles[i]-dfs(i+1, j), piles[j]-dfs(i, j-1))
        }
        return f[i][j]
    }
    return dfs(0, n-1) > 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
function stoneGame(piles: number[]): boolean {
    const n = piles.length;
    const f: number[][] = new Array(n).fill(0).map(() => new Array(n).fill(0));
    const dfs = (i: number, j: number): number => {
        if (i > j) {
            return 0;
        }
        if (f[i][j] === 0) {
            f[i][j] = Math.max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1));
        }
        return f[i][j];
    };
    return dfs(0, n - 1) > 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
impl Solution {
    pub fn stone_game(piles: Vec<i32>) -> bool {
        let n = piles.len();
        let mut f = vec![vec![0; n]; n];

        fn dfs(i: usize, j: usize, piles: &Vec<i32>, f: &mut Vec<Vec<i32>>) -> i32 {
            if i == j {
                return piles[i]
            }
            if f[i][j] != 0 {
                return f[i][j];
            }

            let res = (piles[i] - dfs(i + 1, j, piles, f))
                .max(piles[j] - dfs(i, j - 1, piles, f));

            f[i][j] = res;
            res
        }

        dfs(0, n - 1, &piles, &mut f) > 0
    }
}

Solution 2: Dynamic Programming

We can also use dynamic programming. Define \(f[i][j]\) as the maximum difference in the number of stones the current player can obtain over the other player from piles \(piles[i..j]\). The final answer is then \(f[0][n - 1] \gt 0\).

Initially, \(f[i][i] = piles[i]\), because with only one pile, the current player can only take that pile, and the difference is \(piles[i]\).

For \(f[i][j]\) where \(i \lt j\), there are two cases:

  • If the current player takes pile \(piles[i]\), the remaining piles are \(piles[i + 1..j]\), and it becomes the other player's turn, so \(f[i][j] = piles[i] - f[i + 1][j]\).
  • If the current player takes pile \(piles[j]\), the remaining piles are \(piles[i..j - 1]\), and it becomes the other player's turn, so \(f[i][j] = piles[j] - f[i][j - 1]\).

Therefore, the final state transition equation is \(f[i][j] = \max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1])\).

Finally, we only need to check whether \(f[0][n - 1] \gt 0\).

The time complexity is \(O(n^2)\) and the space complexity is \(O(n^2)\), where \(n\) is the number of stone piles.

Similar problems:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution:
    def stoneGame(self, piles: List[int]) -> bool:
        n = len(piles)
        f = [[0] * n for _ in range(n)]
        for i, x in enumerate(piles):
            f[i][i] = x
        for i in range(n - 2, -1, -1):
            for j in range(i + 1, n):
                f[i][j] = max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1])
        return f[0][n - 1] > 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Solution {
    public boolean stoneGame(int[] piles) {
        int n = piles.length;
        int[][] f = new int[n][n];
        for (int i = 0; i < n; ++i) {
            f[i][i] = piles[i];
        }
        for (int i = n - 2; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = Math.max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1]);
            }
        }
        return f[0][n - 1] > 0;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class Solution {
public:
    bool stoneGame(vector<int>& piles) {
        int n = piles.size();
        int f[n][n];
        memset(f, 0, sizeof(f));
        for (int i = 0; i < n; ++i) {
            f[i][i] = piles[i];
        }
        for (int i = n - 2; ~i; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1]);
            }
        }
        return f[0][n - 1] > 0;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
func stoneGame(piles []int) bool {
    n := len(piles)
    f := make([][]int, n)
    for i, x := range piles {
        f[i] = make([]int, n)
        f[i][i] = x
    }
    for i := n - 2; i >= 0; i-- {
        for j := i + 1; j < n; j++ {
            f[i][j] = max(piles[i]-f[i+1][j], piles[j]-f[i][j-1])
        }
    }
    return f[0][n-1] > 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function stoneGame(piles: number[]): boolean {
    const n = piles.length;
    const f: number[][] = new Array(n).fill(0).map(() => new Array(n).fill(0));
    for (let i = 0; i < n; ++i) {
        f[i][i] = piles[i];
    }
    for (let i = n - 2; i >= 0; --i) {
        for (let j = i + 1; j < n; ++j) {
            f[i][j] = Math.max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1]);
        }
    }
    return f[0][n - 1] > 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
impl Solution {
    pub fn stone_game(piles: Vec<i32>) -> bool {
        let n = piles.len();
        let mut f = vec![vec![0; n]; n];

        for i in 0..n {
            f[i][i] = piles[i];
        }

        for i in (0..n - 1).rev() {
            for j in i + 1..n {
                f[i][j] = (piles[i] - f[i + 1][j])
                    .max(piles[j] - f[i][j - 1]);
            }
        }

        f[0][n - 1] > 0
    }
}

Comments