| 🚀 算法题 🚀 |
🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，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能否获胜，如果可以，返回true，否则返回false。
- 既然题目分先后手来求解，那么我们就可以顺势而为，直接设计俩个递归函数，一个是先手的函数，一个是后手的函数，在区间上选择即可。
- 有了基本的思路，接下来我们就来通过代码来实现一下。
🥦 实现代码
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);
}
}
🥦 运行结果
时间复杂度
空间复杂度
⚡ 记忆化搜索
🥦 求解思路
- 因为在递归的过程中，会重复的出现一些多次计算的结果，我们通过开辟一个数组，将结果提前缓存下来，算过的直接返回，避免重复计算，通过空间来去换我们的时间。
🥦 实现代码
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);
}
}
🥦 运行结果
通过缓存，将重复计算的结果缓存下来，通过。
时间情况
空间情况
⚡ 动态规划
🥦 求解思路
- 有了递归，有了记忆化搜索，接下来就是动态规划了，直接上手。
🥦 实现代码
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;
}
}
🥦 运行结果
动态规划搞定，大家可以积极的尝试。
时间复杂度
空间复杂度
💬 共勉
| 最后，我想和大家分享一句一直激励我的座右铭，希望可以与大家共勉！ |
