[WXM] LeetCode 486. Predict the Winner C++

486. Predict the Winner

Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.

Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.

Example 1:

Input: [1, 5, 2]
Output: False
Explanation: Initially, player 1 can choose between 1 and 2. 
If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2). 
So, final score of player 1 is 1 + 2 = 3, and player 2 is 5. 
Hence, player 1 will never be the winner and you need to return False.

Example 2:

Input: [1, 5, 233, 7]
Output: True
Explanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.

Note:
- 1 <= length of the array <= 20.
- Any scores in the given array are non-negative integers and will not exceed 10,000,000.
- If the scores of both players are equal, then player 1 is still the winner.

Approach

1. 这道题与877. Stone Game题目内容几乎是一样的，不过限制不同，这道题数量变小，但是数组大小随机，而887题是数据量较大，数组数量为偶数，和也为偶数，因为内容几乎是一样，只不过数据大小略有不同，所以解法几乎通用，稍微修改数据即可，我们这里采用记忆化搜索，搜索的思路就是，用一个flag作为标记，当true的时候轮到第一名，那么第一名尽可能的获取到多的分数，当为false的时候轮到第二名，那么第二名就会尽可能的获取到多的分数，我们可以将这块转化为第一名会得到尽可能少的分数，所以搜索方程就出来了flag==true player1=max(DFS(i+1,j)+score[i],DFS(i,j-1)+score[i]) flag==false player1=min(DFS(i+1,j),DFS(i,j+1))，可能会好奇为什么第二个方程是不加数据呢，因为此时不是第一名选，所以不加数据，我们只要知道哪个路口会小就行，因为第二名肯定会选利益最大的路口。

Code

class Solution {
public:
    int DFS(vector<int> &nums, int i, int j, bool flag, vector<vector<vector<int>>> &cache) {
        if (i > j)return 0;
        if (cache[i][j][flag] != 0)return cache[i][j][flag];
        if (flag) {
            cache[i][j][flag] = max(DFS(nums, i + 1, j, false, cache) + nums[i], DFS(nums, i, j - 1, false, cache) + nums[j]);
        }
        else {
            cache[i][j][flag] = min(DFS(nums, i + 1, j, true, cache), DFS(nums, i, j - 1, true, cache));
        }
        return cache[i][j][flag];
    }
    bool PredictTheWinner(vector<int>& nums) {
        if (nums.size() < 2)return true;
        vector<vector<vector<int>>>cache(20, vector<vector<int>>(20, vector<int>(2, 0)));
        int sumA = DFS(nums, 0, nums.size() - 1, true, cache);
        int sum = accumulate(nums.begin(), nums.end(), 0);
        return sumA * 2 >= sum;
    }
};