<p>There is a pizza with <code>3n</code> slices of varying size, you and your friends will take slices of pizza as follows:</p>

<ul>
	<li>You will pick <strong>any</strong> pizza slice.</li>
	<li>Your friend Alice will pick the next slice in the anti-clockwise direction of your pick.</li>
	<li>Your friend Bob will pick the next slice in the clockwise direction of your pick.</li>
	<li>Repeat until there are no more slices of pizzas.</li>
</ul>

<p>Given an integer array <code>slices</code> that represent the sizes of the pizza slices in a clockwise direction, return <em>the maximum possible sum of slice sizes that you can pick</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/18/sample_3_1723.png" style="width: 500px; height: 266px;" />
<pre>
<strong>Input:</strong> slices = [1,2,3,4,5,6]
<strong>Output:</strong> 10
<strong>Explanation:</strong> Pick pizza slice of size 4, Alice and Bob will pick slices with size 3 and 5 respectively. Then Pick slices with size 6, finally Alice and Bob will pick slice of size 2 and 1 respectively. Total = 4 + 6.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/02/18/sample_4_1723.png" style="width: 500px; height: 299px;" />
<pre>
<strong>Input:</strong> slices = [8,9,8,6,1,1]
<strong>Output:</strong> 16
<strong>Explanation:</strong> Pick pizza slice of size 8 in each turn. If you pick slice with size 9 your partners will pick slices of size 8.
</pre>

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

<ul>
	<li><code>3 * n == slices.length</code></li>
	<li><code>1 &lt;= slices.length &lt;= 500</code></li>
	<li><code>1 &lt;= slices[i] &lt;= 1000</code></li>
</ul>

class Solution {
public:

int solve(int index, int end, vector<int>& slices, int n, vector<vector<int>>& dp) {
    if (n == 0 || index > end)
        return 0;

    if (dp[index][n] != -1)
        return dp[index][n];

    int take = slices[index] + solve(index + 2, end, slices, n - 1, dp);
    int nottake = solve(index + 1, end, slices, n, dp);

    return dp[index][n] = max(take, nottake);
}


int solvetab (vector <int> & slices){

int k = slices.size();
  //vector<vector<int>> dp1(k+2, vector<int>(k+2 , 0));
  vector<vector<int>> dp2(k+2, vector<int>(k+2, 0));

  vector <int> prev1(k+2,0);
   vector <int> curr1(k+2,0);
   vector <int> next1(k+2,0);
  

for (int index = k-2;index>=0 ;index--){

for (int n = 1;n<=k/3;n++){

 int take = slices[index] + next1[n - 1] ;
 int nottake = curr1[n] ;

prev1[n] = max(take, nottake);

}
next1 = curr1;
curr1 = prev1;

}
int case1 = curr1[k/3];

   vector <int> prev2(k+2,0);
   vector <int> curr2(k+2,0);
   vector <int> next2(k+2,0);

for (int index = k-1;index>=1 ;index--){

for (int n = 1;n<=k/3;n++){

 int take = slices[index] + next2[n - 1] ;
    int nottake = curr2[n] ;

prev2[n] = max(take, nottake);

}
next2 = curr2;
curr2 = prev2;

}
int case2 = curr2[k/3];

return max(case1,case2);

}

int maxSizeSlices(vector<int>& slices) {
    // int k = slices.size();
    // int n = k / 3;

    // // Separate DP tables for each case
    // vector<vector<int>> dp1(k, vector<int>(k , -1));
    // vector<vector<int>> dp2(k, vector<int>(k , -1));

    // int case1 = solve(0, k - 2, slices, k/3, dp1);
    // int case2 = solve(1, k - 1, slices, k/3, dp2);

    // return max(case1, case2);

return solvetab(slices);




}

};
18600