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

<p>Alice and Bob take turns, with Alice starting first. On each player&#39;s turn, that player can take <code>1</code>, <code>2</code>, or <code>3</code> stones from the <strong>first</strong> remaining stones in the row.</p>

<p>The score of each player is the sum of the values of the stones taken. The score of each player is <code>0</code> initially.</p>

<p>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.</p>

<p>Assume Alice and Bob <strong>play optimally</strong>.</p>

<p>Return <code>&quot;Alice&quot;</code><em> if Alice will win, </em><code>&quot;Bob&quot;</code><em> if Bob will win, or </em><code>&quot;Tie&quot;</code><em> if they will end the game with the same score</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> stoneValue = [1,2,3,7]
<strong>Output:</strong> &quot;Bob&quot;
<strong>Explanation:</strong> 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.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> stoneValue = [1,2,3,-9]
<strong>Output:</strong> &quot;Alice&quot;
<strong>Explanation:</strong> 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&#39;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&#39;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.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> stoneValue = [1,2,3,6]
<strong>Output:</strong> &quot;Tie&quot;
<strong>Explanation:</strong> 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.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= stoneValue.length &lt;= 5 * 10<sup>4</sup></code></li>
	<li><code>-1000 &lt;= stoneValue[i] &lt;= 1000</code></li>
</ul>

class Solution {
public:
    // Method to check whether Alice can win the game or not, using recursion with memoization - O(N) & O(N)
    string stoneGameIII(vector<int>& stoneValue) {
        int n = stoneValue.size();
        vector<vector<int>> memory(n, vector<int>(2, -1));
        int aliceStones = solveWithMemo(memory, stoneValue, n, 0, true);
        int bobStones   = accumulate(begin(stoneValue), end(stoneValue), 0) - aliceStones;
        return (aliceStones >= bobStones) ? (aliceStones == bobStones ? "Tie" : "Alice") : "Bob";
    }

private:
    // O(3*N*2) & O(N*2 + N)
    int solveWithMemo(vector<vector<int>>& memory, vector<int>& stoneValue, int n, int startIndex, bool aliceTurn) {
        // Edge case: If all the piles are exhausted then Alice can't take more stones
        if(startIndex == n)
            return 0;

        // Memoization table: If the current state is already computed then return the computed value
        if(memory[startIndex][aliceTurn] != -1)
            return memory[startIndex][aliceTurn];

        int maxStones  = (aliceTurn) ? INT_MIN : INT_MAX;
        int currStones = 0;

        for(int index = startIndex; index < min(startIndex + 3, n); ++index) {
            currStones += stoneValue[index];

            // If its Alice's turn then she absolutely wanted to win, So for that she wants to maximize her score, so she will take the maximum value from all the possibility
            if(aliceTurn) {
                int nextStones = solveWithMemo(memory, stoneValue, n, index + 1, false);
                maxStones = max(maxStones, nextStones + currStones);
            }
            // If its Bob's turn then he absolutely wanted alice to lose, So for that he wants Alice to minimize her score, so he will take the minimum value from all the possibility
            else {
                int nextStones = solveWithMemo(memory, stoneValue, n, index + 1, true);
                maxStones = min(maxStones, nextStones);
            }
        }   

        // Store the result value to the memoization table and then return it
        return memory[startIndex][aliceTurn] = maxStones;
    }

    // O(3^N) & O(N)
    int solveWithoutMemo(vector<int>& stoneValue, int n, int startIndex, bool aliceTurn) {
        // Edge case: If all the piles are exhausted then Alice can't take more stones
        if(startIndex == n)
            return 0;

        int maxStones  = (aliceTurn) ? INT_MIN : INT_MAX;
        int currStones = 0;

        for(int index = startIndex; index < min(startIndex + 3, n); ++index) {
            currStones += stoneValue[index];

            // If its Alice's turn then she absolutely wanted to win, So for that she wants to maximize her score, so she will take the maximum value from all the possibility
            if(aliceTurn) {
                int nextStones = solveWithoutMemo(stoneValue, n, index + 1, false);
                maxStones = max(maxStones, nextStones + currStones);
            }
            // If its Bob's turn then he absolutely wanted alice to lose, So for that he wants Alice to minimize her score, so he will take the minimum value from all the possibility
            else {
                int nextStones = solveWithoutMemo(stoneValue, n, index + 1, true);
                maxStones = min(maxStones, nextStones);
            }
        }   

        return maxStones;
    }
};

203161