Leetcode 486/877. 预测赢家/石子游戏 （博弈游戏，从轮次开始思考，到去掉轮此）

考虑轮次的局面分递归。

class Solution:
    def PredictTheWinner(self, nums: List[int]) -> bool:
        @lru_cache
        def score(start, end, turn):
            if start == end:
                return turn * nums[start]
            scoreStart = nums[start] * turn + score(start + 1, end, -turn)
            scoreEnd = nums[end] * turn + score(start, end - 1, -turn)
            return max(scoreStart * turn, scoreEnd * turn) * turn

        return score(0, len(nums) - 1, 1) >= 0

实际上，双方的操作应该都是对等的，在博弈的过程中，双方都是为了使得自己的局面分最大，因此最好的定义是：

f[i][j]表示i到j区间上当前玩家与对方玩家局面分的最大值

f[i][j] = max(nuns[i] - f[i+1][j], nums[j] - f[i][j-1]) 

为什么是减法，因为当前先手取了nums[i]后，后手一定会取f[i+1][j]， 因为双方都足够聪明，根据定义，此时我方得分就是nums[i] - f[i+1][j]

class Solution:
    def PredictTheWinner(self, nums: List[int]) -> bool:
        @lru_cache
        def maxScore(start, end):
            if start == end:
                return nums[start]
            return max(nums[start] - maxScore(start + 1, end), nums[end] - maxScore(start, end - 1))
        
        return maxScore(0, len(nums) - 1) >= 0
        

将递归改成循环

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> f(n, vector<int>(n));
        for(int i = 0; i < n; i++){
            f[i][i] = nums[i];
        }
        for(int k = 2; k <= n; k++){
            for(int i = 0; i + k - 1 < n; i++){
                int j = i + k - 1;
                f[i][j] = max(nums[i] - f[i + 1][j], nums[j] - f[i][j - 1]);
            }
        }
        return f[0][n - 1] >= 0;
    }
};