leetcode 486. Predict the Winner (DP)

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

a1025461748

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

阅读量177

点赞数

分类专栏： Leetcode练习

Leetcode练习专栏收录该内容

294 篇文章

订阅专栏

本文探讨了如何预测两个玩家在特定游戏规则下的胜负情况。通过递归和动态规划的方法解决了玩家策略选择的问题，并提供了详细的代码实现。

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.

一开始我的做法是每次取前后两对数进行比较的方法，每次取相对代价（nums[left+1]-nums[left], nums[right-1]-nums[right]）比较小的那个数，但是在最后三个测试例上没通过。。。

//incorrect
public class Solution {
    public boolean PredictTheWinner(int[] nums) {
        if(nums.length==1) return true;
        int left=0, right=nums.length-1;
        int sum1=0, sum2=0;
        int flag=1; 
        int choose=0;
        while(left<right){
            if(nums[left+1]-nums[left]>nums[right-1]-nums[right]){
                choose = right;
                right--;
            }else{
                choose = left;
                left++;
            }
            sum1 += flag * nums[choose];
            sum2 += (1-flag) * nums[choose];
            flag ^= 1;
        }
        sum1 += flag * nums[left];
        sum2 += (1-flag) * nums[left];
        return sum1>=sum2;
    }
}

方法上还是有点问题，不过没想通

看了别人的方法，有递归解决和动态规划的方法

public class Solution {
    public boolean PredictTheWinner(int[] nums) {
        return helper(nums, 0, nums.length-1)>=0;
    }
    private int helper(int[] nums, int s, int e){        
        return s==e ? nums[e] : Math.max(nums[e] - helper(nums, s, e-1), nums[s] - helper(nums, s+1, e));
    }
}

public boolean PredictTheWinner(int[] nums) {
    if (nums == null) { return true; }
    int n = nums.length;
    if ((n & 1) == 0) { return true; } // Improved with hot13399's comment.
    int[] dp = new int[n];
    for (int i = n - 1; i >= 0; i--) {
        for (int j = i; j < n; j++) {
            if (i == j) {
                dp[i] = nums[i];
            } else {
                dp[j] = Math.max(nums[i] - dp[j], nums[j] - dp[j - 1]);
            }
        }
    }
    return dp[n - 1] >= 0;
}

这类游戏问题把大问题划分到子问题以及动态规划的想法还是得好好琢磨一下