leetcode 486. Predict the Winner

最新推荐文章于 2025-05-22 02:00:00 发布

feifeiiong

最新推荐文章于 2025-05-22 02:00:00 发布

阅读量349

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ leetcode 算法文章标签： leetcode 动态规划

本文链接：https://blog.csdn.net/feifeiiong/article/details/78738976

C++ 同时被 3 个专栏收录

63 篇文章

订阅专栏

leetcode

56 篇文章

订阅专栏

算法

53 篇文章

订阅专栏

本文介绍了一道典型的动态规划题目，玩家从数组两端取数，最终得分高者胜出。文章详细解析了如何通过动态规划预测游戏胜负，并给出具体算法实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

写在前面

二刷过程中一道经典的动态规划题目，可以帮我们更深入和细致地理解动态规划过程。

题目描述

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.

思路分析

判断一个题目能否用动态规划求解的关键就是问题本身是否能够转换成子问题的组合。子问题之间，通过状态转移方程来保持关联。后一个子问题的解是前一个子问题通过状态转移方程求解得到。由此可以得出一个基本的结论，动态规划问题的解与问题规模没有关系，关键在于找到构成子问题间联系的状态转移方程。有一些问题的状态转移方程不太明显，导致很难求解（leetcode 241 状态转移通过运算符体现）。另外，还有一些问题可以通过自顶向下方式求解，这种解法通常使用递归作为求解方式。自顶向下的过程，通常是拆分子问题的过程，也因此，通常也可用自底向上的方式求解，本题就属于这一类。

我们首先写出自顶向下的问题解，再考虑自底向上的过程。对于本题，题目要求是预测胜者，两个人分别从数组的两端选择，他们都会以最优方式选择，这里有一个技巧，我们知道获胜那一方最后拿到的分数一定是比另一方多的，因此，这里的动态规划算法考虑的是两者的差值。也就是说，一方拿到的分数去减去另一方拿到的分数，如果最后大于0就获胜。这种思想复现的算法如下：

class Solution {
    bool PredictTheWinner(vector<int> nums) {
    vector<vector<int>> dp(nums.size(),vector<int>(nums.size(),0);
        return helper(nums, 0, nums.length-1, dp)>=0;
    }
    int helper(vector<int>&nums, int s, int e, vector<vector<int>>& dp){    
        if(dp[s][e]==0)
            dp[s][e] = s==e ? nums[e] : max(nums[e]-helper(nums,s,e-1,dp),nums[s]-helper(nums,s+1,e,dp));
        return dp[s][e];
    }
}

非递归写法接下来更新。