Stone Game III

Leetcode Daily Challenge (27th May, 2023)

Stone Game III

Problem Statement:-

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.

Link: https://leetcode.com/problems/stone-game-iii/description/

Problem Explanation with examples:-

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. 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: 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.

Constraints

  • 1 <= stoneValue.length <= 5 * 10<sup>4</sup>

  • -1000 <= stoneValue[i] <= 1000

Intuition:-

  • A similar dp function can be used like in stone game 2. But this time we need to keep track of the score of both players.

  • Here we have to return the result of the game, so basically we need to know the difference between the scores of both players.

  • That is exactly what our function will do. When it is Alice's turn, it will return Alice's score - Bob's score. And when it is Bob's turn, it will return Bob's score - Alice's score.

  • This can be achieved recursively by subtracting the result of the next player's turn from the current player's turn.

  • Finally, we will check if the result is positive, negative, or zero and return the result accordingly.

Solution:-

  • Create a function solve(i) which will return the difference between the scores of Alice and Bob if the game starts from index I.

  • In the function, we will check if the index is out of bounds. If it is, we will return 0.

  • If the index is not out of bounds, we will iterate over the next 3 indices and call the function recursively.

  • ans variable will be the maximum of ans and the difference between the sum of the current subarray and the result of the next player's turn.

  • Finally, we will return and.

  • In the main function, we will call solve(0) and check if the result is positive, negative, or zero, and return the result accordingly.

Code:-

JAVA Solution

class Solution {
    public String stoneGameIII(int[] stoneValue) {
        int n = stoneValue.length;
        int[] dp = new int[n+1];
        Arrays.fill(dp, Integer.MIN_VALUE);
        dp[n] = 0;

        for (int i = n-1; i >= 0; i--) {
            int sum = 0;
            for (int j = i; j < Math.min(i+3, n); 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";
        }
    }
}

Python Solution

class Solution:
    def stoneGameIII(self, stoneValue: List[int]) -> str:
        @cache
        def solve(i):
            if i >= len(stoneValue):
                return 0

            ans = float('-inf')
            for j in range(i,min(i+3,len(stoneValue))):
                ans = max(ans, sum(stoneValue[i:j+1])-solve(j+1))

            return ans

        return "Alice" if solve(0)>0 else ("Bob" if solve(0)<0 else "Tie")

Complexity Analysis:-

TIME:-

The time complexity of add method is O(n) where n is the length of the array. This is because we are using memoization and it's a 1D dp with a for loop iterating over 3 elements at max which is constant and can be ignored.

SPACE:-

The space complexity is O(n) where n is the length of the array. We are storing the result of each index in the dp array or map.

References:-

Connect with me:-

Did you find this article valuable?

Support Leeting-LCS by becoming a sponsor. Any amount is appreciated!