<p>Alice and Bob play a game with piles of stones. There are an <strong>even</strong> number of piles arranged in a row, and each pile has a <strong>positive</strong> integer number of stones <code>piles[i]</code>.</p>

<p>The objective of the game is to end with the most stones. The <strong>total</strong> number of stones across all the piles is <strong>odd</strong>, so there are no ties.</p>

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

<p>Assuming Alice and Bob play optimally, return <code>true</code><em> if Alice wins the game, or </em><code>false</code><em> if Bob wins</em>.</p>

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

<pre>
<strong>Input:</strong> piles = [5,3,4,5]
<strong>Output:</strong> true
<strong>Explanation:</strong> 
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.
</pre>

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

<pre>
<strong>Input:</strong> piles = [3,7,2,3]
<strong>Output:</strong> true
</pre>

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

<ul>
	<li><code>2 &lt;= piles.length &lt;= 500</code></li>
	<li><code>piles.length</code> is <strong>even</strong>.</li>
	<li><code>1 &lt;= piles[i] &lt;= 500</code></li>
	<li><code>sum(piles[i])</code> is <strong>odd</strong>.</li>
</ul>

class Solution {
public:
    // int solve(int i, int j, bool can_take, vector<int>& piles) {
    //     if (i > j) {
    //         return 0;
    //     }
    //     if (i == j) {
    //         return can_take ? piles[i] : 0;
    //     }
    //     int left = solve(i + 1, j, !can_take, piles);
    //     if (can_take) {
    //         left += piles[i];
    //     }
    //     int right = solve(i, j - 1, !can_take, piles);
    //     if (can_take) {
    //         right += piles[j];
    //     }
    //     int result = max(left, right);
    //     return result;
    // }
    // bool stoneGame(vector<int>& piles) {
    //     int total = 0;
    //     for (int& num : piles) {
    //         total += num;
    //     }
    //     int alice_total = solve(0, piles.size() - 1, true, piles);
    //     int bob_total = total - alice_total;
    //     return alice_total > bob_total;
    // }
    bool stoneGame(vector<int>& piles) {
        int n = piles.size();
        vector<vector<vector<int>>> dp(
            n, vector<vector<int>>(n, vector<int>(2, 0)));

        for (int i = 0; i < n; ++i) {
            dp[i][i][1] = piles[i];
        }

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                for (int can_take = 0; can_take <= 1; ++can_take) {
                    int left = dp[i + 1][j][can_take == 1 ? 0 : 1];
                    if (can_take) {
                        left += piles[i];
                    }

                    int right = dp[i][j - 1][can_take == 1 ? 0 : 1];
                    if (can_take) {
                        right += piles[j];
                    }
                    int result = max(left, right);
                    dp[i][j][can_take] = result;
                }
            }
        }

        int total = 0;
        for (int& num : piles) {
            total += num;
        }
        int alice_total = dp[0][piles.size() - 1][1];
        int bob_total = total - alice_total;
        return alice_total > bob_total;
    }
};
83524