频率很高的笔试题--动态规划类型(中)

1、预测赢家

给定一个表示分数的非负整数数组。 玩家1从数组任意一端拿取一个分数，随后玩家2继续从剩余数组任意一端拿取分数，然后玩家1拿，……。每次一个玩家只能拿取一个分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。

给定一个表示分数的数组，预测玩家1是否会成为赢家。你可以假设每个玩家的玩法都会使他的分数最大化。

示例1
输入: [1, 5, 2]
输出: False
解释: 一开始，玩家1可以从1和2中进行选择。
如果他选择2（或者1），那么玩家2可以从1（或者2）和5中进行选择。如果玩家2选择了5，那么玩家1则只剩下1（或者2）可选。
所以，玩家1的最终分数为 1 + 2 = 3，而玩家 2 为 5
因此，玩家1永远不会成为赢家，返回 False

示例2
输入: [1, 5, 233, 7]
输出: True
解释: 玩家1一开始选择1。然后玩家2必须从5和7中进行选择。无论玩家2选择了哪个，玩家1都可以选择233
最终，玩家1（234分）比玩家2（12分）获得更多的分数，所以返回 True，表示玩家1可以成为赢家

思路：这道题还是很难理解的，首先 dp[i][j] 表示的意思是先手比后手多拿的分数.

动态转移方程为：
dp = max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1])

    def PredictTheWinner(self, nums: List[int]) -> bool:
        # 如果个数时偶数的话，玩家1一定赢
        # 因为共有两种选择方案，一种赢一种输，让玩家1那选赢的那一方就行了
        # 输赢是由方案的选择决定的
        if len(nums)%2==0:
            return True
        # 如果是奇数的话，输赢是根据先手或者后手决定的
        # 先手可能会赢，也可能会输，但是题目要求的是玩家1先手
        # 所以就是接下来就是判断，先手拿数字是输还是赢？
        n = len(nums)
        dp = [[0]*n for _ in nums]  
        for j in range(n):
            for i in range(j-1, -1, -1):                 
                dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1])         
        return dp[0][n-1]>=0

C++版本

    bool PredictTheWinner(vector<int>& nums) {
   
        int n = nums.size();
        if(n%2==0){
   
            return true;
        }
        vector<vector<int>>dp(n,vector<int>(n,0));
        for(int i = n-1;i>=0;--i){
   
            dp[i][i] = nums[i];
            for(int j = i+1;j<n;++j){
   
                dp[i][j] = max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1]);
            }
        }
        return dp[0][n-1]>=0;
    }

2、乘积最大子序列

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）

示例
输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6

示例2
输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组

注意事项：比较典型的错误思维

    def maxProduct(self, nums: List[int]) -> int:
        n = len(nums)
        dp_max = [nums[0]]*n
        res = nums[0]
        for i in range(1,n):  
            dp_max[i] = max(dp_max[i-1]*nums[i], nums[i])
            res = max(res,dp_max[i])           
        return res

如果计算的最大子序列和，这种思路就是对的。

存在一种情况是，负数乘以负数得到的是正数
就比如下面案列

案列3：[-2,3,-4]

如果返回的是3，就错了，最大子序列积应该是 24

所以在遍历的时候，不应该保存最大值，同时也把最小值保存下来，说不定下一个数是负数，然后就把最小的数变为最大的数了

参考 code

    int maxProduct(vector<int>& nums) {
   
        int n = nums.size();
        int a = 1,b=1;
        int maxVal = INT_MIN;
        for(int i = 0;i<n;++i){
   
            int aa = a * nums[i];
            int bb = b * nums[i];

            a