1406. Stone Game III LeetCode Solution

Last updated: February 23, 2025

In this guide, you will get 1406. Stone Game III LeetCode Solution with the best time and space complexity. The solution to Stone Game III problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Problem Statement
Complexity Analysis
Stone Game III solution in C++
Stone Game III solution in Java
Stone Game III solution in Python
Additional Resources

1406. Stone Game III LeetCode Solution image

Problem Statement of Stone Game III

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] <= 1000

Complexity Analysis

Time Complexity: O(n)
Space Complexity: O(n)

1406. Stone Game III LeetCode Solution in C++

class Solution {
 public:
  string stoneGameIII(vector<int>& stoneValue) {
    vector<int> mem(stoneValue.size(), INT_MIN);
    const int score = stoneGameIII(stoneValue, 0, mem);
    return score > 0 ? "Alice" : score < 0 ? "Bob" : "Tie";
  }

 private:
  // Returns the maximum relative score Alice can make from stoneValue[i..n).
  int stoneGameIII(const vector<int>& stoneValue, int i, vector<int>& mem) {
    if (i == stoneValue.size())
      return 0;
    if (mem[i] > INT_MIN)
      return mem[i];

    int sum = 0;
    for (int j = i; j < i + 3 && j < stoneValue.size(); ++j) {
      sum += stoneValue[j];
      mem[i] = max(mem[i], sum - stoneGameIII(stoneValue, j + 1, mem));
    }

    return mem[i];
  };
};
/* code provided by PROGIEZ */

1406. Stone Game III LeetCode Solution in Java

class Solution {
  public String stoneGameIII(int[] stoneValue) {
    int[] mem = new int[stoneValue.length];
    Arrays.fill(mem, Integer.MIN_VALUE);
    final int score = stoneGameIII(stoneValue, 0, mem);
    return score > 0 ? "Alice" : score < 0 ? "Bob" : "Tie";
  }

  // Returns the maximum relative score Alice can make from stoneValue[i..n).
  private int stoneGameIII(int[] stoneValue, int i, int[] mem) {
    if (i == stoneValue.length)
      return 0;
    if (mem[i] > Integer.MIN_VALUE)
      return mem[i];

    int sum = 0;
    for (int j = i; j < i + 3 && j < stoneValue.length; ++j) {
      sum += stoneValue[j];
      mem[i] = Math.max(mem[i], sum - stoneGameIII(stoneValue, j + 1, mem));
    }

    return mem[i];
  };
}
// code provided by PROGIEZ

1406. Stone Game III LeetCode Solution in Python

class Solution:
  def stoneGameIII(self, stoneValue: list[int]) -> str:
    @functools.lru_cache(None)
    def dp(i: int) -> int:
      """
      Returns the maximum relative score Alice can make with stoneValue[i..n).
      """
      if i == len(stoneValue):
        return 0

      res = -math.inf
      summ = 0

      for j in range(i, i + 3):
        if j == len(stoneValue):
          break
        summ += stoneValue[j]
        res = max(res, summ - dp(j + 1))

      return res

    score = dp(0)
    if score == 0:
      return 'Tie'
    return 'Alice' if score > 0 else 'Bob'
 # code by PROGIEZ

Additional Resources

Happy Coding! Keep following PROGIEZ for more updates and solutions.

Table of Contents