"生活没有真正的赢家"

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第27天，点击查看活动详情

🔴 从今天开始更新近期面试 MS 等外企的小伙伴们遇到的一系列题目的题解。

486. 预测赢家 题目描述：给你一个整数数组 nums 。玩家 1 和玩家 2 基于这个数组设计了一个游戏。

玩家 1 和玩家 2 轮流进行自己的回合，玩家 1 先手。开始时，两个玩家的初始分值都是 0 。每一回合，玩家从数组的任意一端取一个数字（即，nums[0] 或 nums[nums.length - 1]），取到的数字将会从数组中移除（数组长度减 1 ）。玩家选中的数字将会加到他的得分上。当数组中没有剩余数字可取时，游戏结束。

如果玩家 1 能成为赢家，返回 true 。如果两个玩家得分相等，同样认为玩家 1 是游戏的赢家，也返回 true 。你可以假设每个玩家的玩法都会使他的分数最大化。

中规中矩的动态规划

玩家每次选择元素时，都有两种选择，即从 当前数组 中 start 或 end 索引处选择，故形成一种递归形式，时间复杂度为 $O(2^n)$，如下图。同时我们记录一个 diff 值代表先手玩家1与后手玩家2之间的最大差值，当 $diff \ge 0$ 玩家1获胜，返回 $true$，否则返回 $false$。

递归形式存在大量重复计算，而且存在重复子问题，因此可以尝试使用动态规划算法来降低时间复杂度。

1、确定 dp 状态数组

定义 $dp[i][j]$ 为数组 $[i,j]$ 区间内玩家1与玩家2的最大差值，其中 $0 \le i \le j < n$，$n = nums.length$

2、确定 dp 状态方程

当前可选区域为 $nums[i,j]$，即当前要选择元素的玩家可以选择，$num[i]$ 或 $num[j]$,

• 如果选择 $nums[i]$，此时数组 $[i,j]$ 区间内玩家1与玩家2的最大差值（$dp[i][j]$），应该与数组 $[i+1,j]$ 区间内玩家1与玩家2的最大差值（$dp[i + 1][j]$）相关，即 $dp[i][j] = nums[i] - dp[i + 1][j]$；

• 同理如果选择 $nums[j]$，此时数组 $[i,j]$ 区间内玩家1与玩家2的最大差值（$dp[i][j]$），应该与数组 $[i,j-1]$ 区间内玩家1与玩家2的最大差值（$dp[i][j-1]$）相关，即 $dp[i][j] = nums[j] - dp[i][j-1]$；

综上所述，

3、确定 dp 初始状态

当 $i = j$（只有一个元素可选）时，$dp[i][j] = num[i]$（需要循环遍历数组）

4、确定遍历顺序

• 外层循环从 $i = n - 2$ 遍历到 $i = 0$；

• 内层循环从 $j = i + 1$ 遍历到 $j = n - 1$。

5、确定最终返回值

$dp[0][n-1]$ 为数组 $[0,n)$ 区间内玩家1与玩家2的最大差值。当 $dp[0][n-1] \ge =0$，返回 $true$，否则返回 $false$。

6、代码示例

/**
 * 空间复杂度 O(n^2),n是nums数组的长度
 * 时间复杂度 O(n^2)
 */
function PredictTheWinner(nums: number[]): boolean {
    const n = nums.length;
    const dp = Array.from({ length: n }, () => new Array(n).fill(0));

    for (let i = 0; i < n; i++) {
        dp[i][i] = nums[i];
    }

    for (let i = n - 2; i >= 0; i--) {
        for (let j = i + 1; j < n; j++) {
            dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
        }
    }

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

状态压缩

/**
 * 空间复杂度 O(n^2),n是nums数组的长度
 * 时间复杂度 O(n)
 */
function PredictTheWinner(nums: number[]): boolean {
    const n = nums.length;
    const dp = [...nums]; // 初始化dp

    for (let i = n - 2; i >= 0; i--) {
        for (let j = i + 1; j < n; j++) {
            dp[j] = Math.max(nums[i] - dp[j], nums[j] - dp[j - 1]);
        }
    }

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

参考

# 重识动态规划