486. 预测赢家

Problem: 486. 预测赢家

思路

这道题是典型的动态规划问题，可以采用递归或递推的方式解决。关键在于理解游戏的规则和策略。在每一步中，玩家可以选择数组中的第一个或最后一个元素，因此需要考虑两种情况并选择最优解。

解题方法

方法一：暴力递归

直接使用递归函数计算先手玩家的最大得分。从数组的两端开始选择，并递归计算剩余子数组的得分。然而，这种方法的时间复杂度非常高，因为存在大量的重复计算。

方法二：记忆化搜索

通过使用记忆化搜索（即带有缓存的递归），我们可以避免重复计算相同子问题的结果，从而显著提高效率。将每次计算的结果存储在一个二维数组中，以便后续使用。

方法三：动态规划

利用动态规划的思想，从数组的内部向外部构建状态转移方程。我们用dp[i][j]表示从nums[i]到nums[j]的子数组中先手玩家的最大得分。通过迭代更新dp数组，最终得到整个数组中先手玩家的最大得分。

复杂度

时间复杂度:

暴力递归: $O(2^n)$
记忆化搜索: $O(n^2)$
动态规划: $O(n^2)$

空间复杂度:

暴力递归: $O(n)$（递归栈）
记忆化搜索: $O(n^2)$（缓存数组）
动态规划: $O(n^2)$（dp数组）

Code

class Solution {
    // 暴力尝试
    public boolean predictTheWinner1(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        int n = nums.length;
        int first = f1(nums, 0, n - 1);
        int second = sum - first;
        return first >= second;
    }
    public int f1(int[] nums, int l, int r) {
        if(l == r) {
            return nums[l];
        }
        if(l + 1 == r) {
            return Math.max(nums[l], nums[r]);
        }
        // 可能性1； 玩家1拿走nums[l]
        int p1 = nums[l] + Math.min(f1(nums, l + 2, r), f1(nums, l + 1, r - 1));
        // 可能性2： 玩家1拿走nums[r]
        int p2 = nums[r] + Math.min(f1(nums, l, r - 2), f1(nums, l + 1, r - 1));
        return Math.max(p1, p2);

    }
    public boolean predictTheWinner2(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        int n = nums.length;
        int[][] dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = -1;
            }
        }
        int first = f2(nums, 0, n - 1, dp);
        int second = sum - first;
        return first >= second;
    }

    public int f2(int[] nums, int l, int r, int[][] dp) {
        if (dp[l][r] != -1) {
            return dp[l][r];
        }
        int ans;
        if (l == r) {
            ans = nums[l];
        } else if (l + 1 == r) {
            ans = Math.max(nums[l], nums[r]);
        } else {
            // 可能性1； 玩家1拿走nums[l]
            int p1 = nums[l] + Math.min(f2(nums, l + 2, r, dp), f2(nums, l + 1, r - 1, dp));
            // 可能性2： 玩家1拿走nums[r]
            int p2 = nums[r] + Math.min(f2(nums, l, r - 2, dp), f2(nums, l + 1, r - 1, dp));
            ans = Math.max(p1, p2);
        }

        dp[l][r] = ans;
        return ans;

    }
    
    // 严格位置依赖的动态规划
    public boolean predictTheWinner(int[] nums) {
        int n = nums.length;
        int[][] dp = new int[n + 1][n + 1];
        int sum = 0;
        for(int num : nums) {
            sum += num;
        }
        for(int i = 0; i < n - 1; i++) {
            dp[i][i] = nums[i];
            dp[i][i + 1] = Math.max(nums[i], nums[i + 1]);
        }
        dp[n - 1][n - 1] = nums[n - 1];
        for(int l = n - 3; l >= 0; l--) {
            for(int r = l + 2; r < n; r++) {
                dp[l][r] =  Math.max(nums[l] + Math.min(dp[l + 2][r], dp[l + 1][r - 1]), nums[r] + Math.min(dp[l][r - 2], dp[l + 1][r - 1]));
            }
        }
        int first = dp[0][n - 1];
        int second = sum - first;
        return first >= second;
    }
}