力扣p877(石子游戏1）

力扣p877(石子游戏1）

题解:
方法一:递归
通过递归遍历每一种选择方案，用一个标志sym来标志此轮是谁进行选择,，只要有一次Alex的分数大于Li的分数，就返回True
时间复杂度(O(2^n),这里提交超时，n很大时，时间复杂度呈现指数增长

class Solution {
public:
    bool find(vector<int> &piles,int l,int r,int a1,int a2,int sym){
        if(l>r) return a1>a2;
        if(sym==0){
            return find(piles,l+1,r,a1+piles[l],a2,(sym+1)%2)||find(piles,l,r-1,a1+piles[r],a2,(sym+1)%2);
        }
        else if(sym==1){
            return find(piles,l+1,r,a1,a2+piles[l],(sym+1)%2)||find(piles,l,r-1,a1,a2+piles[r],(sym+1)%2);
        }
        return false;
    }
    bool stoneGame(vector<int>& piles) {
        int len=piles.size();
        int a1=0,a2=0;
        return find(piles,0,len-1,a1,a2,0);
    }
};

方法二:动态规划+前缀和

由于每次只能从行的开始或结束处取走整堆石子，因此可以保证剩下的石子堆一定是连续的。

如果只剩下一堆石子，则当前玩家只能取走这堆石子。如果剩下多堆石子，则当前玩家可以选择从行的开始或结束处取走整堆石子，然后轮到另一个玩家在剩下的石子堆中取走石子。这是一个递归的过程，因此可以使用递归进行求解，但无法通过所有的测试用例。递归的时间复杂度高的原因是存在大量重复计算。由于存在重复子问题，因此可以使用动态规划降低时间复杂度。

定义二维数组dp，其行数和列数都等于石子的堆数，dp[i][j]表示当剩下的石子堆为下标 i 到下标 j 时，当前玩家与另一个玩家的石子数量之差的最大值，注意当前玩家不一定是先手 Alex。

只有当 i≤j 时，剩下的石子堆才有意义，因此当 i>j 时，dp[i][j]=0。

当 i=j 时，只剩下一堆石子，当前玩家只能取走这堆石子，因此对于所有 0 0≤i<nums.length，都有 dp[i][i]=piles[i]。

当 i<j 时，当前玩家可以选择取走 piles[i] 或 piles[j]，然后轮到另一个玩家在剩下的石子堆中取走石子。在两种方案中，当前玩家会选择最优的方案，使得自己的石子数量最大化。因此可以得到如下状态转移方程：

dp[i][j]=max(piles[i]−dp[i+1][j],piles[j]−dp[i][j−1])
可以注意到，我们应该从后面从前开始遍历，因为当i=3，j=6时，如果取左边i=3，那么我们会用到4~6这个状态。
即使取j=6，我们要用到3-5这个状态，但是因为j从i+1开始遍历，所以3-5这个状态可以在求3-6这个状态之前把3-5这个状态求出。

最后判断dp[0][piles.length−1] 的值，如果大于 0，则 Alex 的石子数量大于 Lee 的石子数量，因此Alex 赢得比赛，否则 Lee 赢得比赛。

class Solution {
public:
    
    bool stoneGame(vector<int>& piles) {
        int len=piles.size();
        vector<vector<int> > dp(len,vector<int>(len));
        for(int i=0;i<len;++i){
            dp[i][i]=piles[i];
        }
        for(int i=len-2;i>=0;--i){
            for(int j=i+1;j<len;++j){
                dp[i][j]=max(piles[i]-dp[i+1][j],piles[j]-dp[i][j-1]);
            }
        }
        return dp[0][len-1];
    }
};