<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(vector<int> v,  int i ,int j, vector<vector<int>> &dp){
        if(i>j) return 0;

        if(dp[i][j]!=-1) return dp[i][j];

       int a= solve(v, i+1, j-1, dp) + v[i];
       int b=  solve(v, i+1, j-1, dp) + v[j];

        return dp[i][j] = max(a, b);
    }
    bool stoneGame(vector<int>& p) {
        
        // [3,2,10,4]
        // 3 
        // 2 10 4

        int n = p.size();
        int i=0, j=n-1, a=0, b=0, turn= 1, sum=0;
        
        vector<vector<int>> dp(n+1,vector<int> (n+1, -1));

        for(int l=0; l<n; l++){
            sum+=p[l];
        }
        int num = solve(p, i, j, dp);
        sum-=num;
        cout<<sum<<" "<<num<<"\n";

        if(sum <=num) return 1;
        return 0;

        // while(i<j){
        //     if(turn){
        //         if(p[i]> p[j]) {
        //             a+=p[i];
        //             i++;
        //         }else {
        //             a+=p[j];
        //             j--;
        //         }
        //         turn =0;
        //     }else {
        //         if(p[i]> p[j]) {
        //             b+=p[i];
        //             i++;
        //         }else {
        //             b+=p[j];
        //             j--;
        //         }
        //         turn =1;
        //     }
        // }

        // // cout<<a<<" "<<b<<endl;

        // return a>b;
    }
};
28974