leetcode 486. Predict the Winner 预测最后赢家+数组头尾部取元素求和+动态规划DP

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.

题意是这样的，给定一个正整数数组，选手1从数组的头部或者尾部选择一个数，选手2从剩下部分的头部或尾部选择一个数，循环往复，直到该数组中的数都被取完。判断选手1取的数的和值是否大于选手2.

两人依次拿，如果Player1赢，则Player1拿的>Player2拿的。我们把Player1拿的视为”+”，把Player2拿的视为”-“，如果最后结果大于等于0则Player1赢。

因此对于递归来说，beg ~ end的结果为max(nums[beg] - partition(beg + 1, end), nums[end] - partition(beg, end + 1))；对于非递归来说DP[beg][end]表示即为beg ~ end所取的值的大小（最终与零比较），递归的做法如下：

建议和leetcode 464. Can I Win 100相加游戏 + 一个十分棒的深度优先遍历DFS的做法

代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>

using namespace std;

class Solution 
{
public:
    bool PredictTheWinner(vector<int>& nums)
    {
        int res = dfs(nums, 0, nums.size() - 1);
        return res >= 0;
    }

    int dfs(vector<int> nums, int beg, int end)
    {
        if (beg == end)
            return nums[beg];
        else
            return max(nums[beg]-dfs(nums,beg+1,end), nums[end]-dfs(nums, beg, end-1));
    }
};

非递归的做法和上面类似，是一个DP动态规划的做法，dp[i][j]表示index从i到j的计算结果，那么我们最终要判断dp[0][size-1]>=0与否，很明显对角线上的值，dp[i][i] = nums[i]，然后就开始递归了，

代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>

using namespace std;

class Solution 
{
public:
    bool PredictTheWinner(vector<int>& nums)
    {
        int len = nums.size();
        vector<vector<int>> dp(len, vector<int>(len, 0));
        for (int i = 0; i < len; i++)
            dp[i][i] = nums[i];

        for (int beg = len - 2; beg >= 0; beg--)
        {
            for (int end = beg + 1; end < len; end++)
            {
                dp[beg][end] = max(nums[beg] - dp[beg + 1][end], nums[end] - dp[beg][end - 1]);
            }
        }

        return dp[0][len - 1] >= 0;
    }

    bool PredictTheWinnerByDFS(vector<int>& nums)
    {
        int res = dfs(nums, 0, nums.size() - 1);
        return res >= 0;
    }

    int dfs(vector<int> nums, int beg, int end)
    {
        if (beg == end)
            return nums[beg];
        else
            return max(nums[beg]-dfs(nums,beg+1,end), nums[end]-dfs(nums, beg, end-1));
    }
};