【LeetCode: 486. 预测赢家 | 暴力递归=＞记忆化搜索=＞动态规划 】

算法题

算法刷题专栏 | 面试必备算法 | 面试高频算法
越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
作者简介：硕风和炜，CSDN-Java领域优质创作者，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享
恭喜你发现一枚宝藏博主,赶快收入囊中吧
人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？

算法题

题目链接

• 486. 预测赢家

⛲ 题目描述

给你一个整数数组 nums 。玩家 1 和玩家 2 基于这个数组设计了一个游戏。

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

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

示例 1：

输入：nums = [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：

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

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 107

求解思路&实现代码&运行结果

---

⚡ 暴力法

求解思路

1. 简单概括题目的意思:这道题目是一道典型的博弈类型的题目，我们分为先后手，每次我们可以从数组中最左侧或者最右侧取出一个数字，然后对手进行选择，俩个人都绝顶聪明，让我们求得最后玩家1能否获胜，如果可以，返回true，否则返回false。
2. 既然题目分先后手来求解，那么我们就可以顺势而为，直接设计俩个递归函数，一个是先手的函数，一个是后手的函数，在区间上选择即可。
3. 有了基本的思路，接下来我们就来通过代码来实现一下。

实现代码

class Solution {
  public boolean PredictTheWinner(int[] arr) {
			if (arr == null || arr.length == 0) {
				return false;
			}
			int first = f1(arr, 0, arr.length - 1);
			int second = g1(arr, 0, arr.length - 1);
			return first>=second;
	}

	public static int f1(int[] arr, int L, int R) {
		if (L == R) {
			return arr[L];
		}
		int p1 = arr[L] + g1(arr, L + 1, R);
		int p2 = arr[R] + g1(arr, L, R - 1);
		return Math.max(p1, p2);
	}

	public static int g1(int[] arr, int L, int R) {
		if (L == R) {
			return 0;
		}
		int p1 = f1(arr, L + 1, R);
		int p2 = f1(arr, L, R - 1);
		return Math.min(p1, p2);
	}
}

运行结果

时间复杂度

空间复杂度

---

⚡ 记忆化搜索

求解思路

1. 因为在递归的过程中，会重复的出现一些多次计算的结果，我们通过开辟一个数组，将结果提前缓存下来，算过的直接返回，避免重复计算，通过空间来去换我们的时间。

实现代码

class Solution {

	int[][] dp1;
	int[][] dp2;

  public boolean PredictTheWinner(int[] arr) {
			if (arr == null || arr.length == 0) {
				return false;
			}
			int n=arr.length;
			dp1=new int[n][n];
			dp2=new int[n][n];
			int first = f1(arr, 0, arr.length - 1);
			int second = g1(arr, 0, arr.length - 1);
			return first>=second;
	}

	public int f1(int[] arr, int L, int R) {
		if (L == R) {
			return dp1[L][R]=arr[L];
		}
		int p1 = arr[L] + g1(arr, L + 1, R);
		int p2 = arr[R] + g1(arr, L, R - 1);
		return dp1[L][R]=Math.max(p1, p2);
	}

	public int g1(int[] arr, int L, int R) {
		if (L == R) {
			return dp2[L][R]=0;
		}
		int p1 = f1(arr, L + 1, R);
		int p2 = f1(arr, L, R - 1);
		return dp2[L][R]=Math.min(p1, p2);
	}
}

运行结果

通过缓存，将重复计算的结果缓存下来，通过。
时间情况

空间情况

---

⚡ 动态规划

求解思路

1. 有了递归，有了记忆化搜索，接下来就是动态规划了，直接上手。

实现代码

class Solution {
    public boolean PredictTheWinner(int[] nums) {
        int length = nums.length;
        int[][] dp = new int[length][length];
        for (int i = 0; i < length; i++) {
            dp[i][i] = nums[i];
        }
        for (int i = length - 2; i >= 0; i--) {
            for (int j = i + 1; j < length; j++) {
                dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
            }
        }
        return dp[0][length - 1] >= 0;
    }
}

运行结果

动态规划搞定，大家可以积极的尝试。

时间复杂度

空间复杂度

---

共勉

最后，我想和大家分享一句一直激励我的座右铭，希望可以与大家共勉！