leetcode.486. 预测赢家
预测赢家
leetcode 486 题
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/predict-the-winner
题目描述
暴力递归
解题思路
代码演示
public boolean PredictTheWinner(int[] nums) {
if(null == nums || nums.length == 1){
return true;
}
//暴力递归
int f = f(nums,0,nums.length - 1);
int g = g(nums,0,nums.length - 1);
return f >= g ? true : false;
}
/**
* 先手的递归
* nums 要拿的数组
* left 左边界
* right 右边界
*/
public int f(int[]nums,int left,int right){
//base case 只剩一个数时，肯定鬼先手方
if(left == right){
return nums[left];
}
//两种情况去考虑，拿左边和拿右边
//拿左边的后， 后手方从剩下的里去拿
int p1 = nums[left] + g(nums,left + 1,right);
//拿完右边 下面要后手方拿
int p2 = nums[right] + g(nums,left,right - 1);
//取最大值
return Math.max(p1,p2);
}
/**
* 后手的递归
* nums 要拿的数组
* left 左边界
* right 右边界
*/
public int g(int[]nums,int left,int right){
//base case 只剩一个时，后手没法拿 只能得到0
if(left == right){
return 0;
}
//后手要在先手拿完之后的数组中选，
//因此要把先手拿左边右边两种情况都考虑到
// 先手拿左边的，只能从left + 1 以后去选了
int g1 = f(nums,left + 1,right);
//先手拿右边的，只能从left 和 right -1 去选了
int g2 = f(nums,left,right - 1);
//因为先手一定去拿最优解，所以后手方只能拿到次优的
return Math.min(g1,g2);
}
暴力递归 + 缓存
解题思路
代码演示
public boolean PredictTheWinner(int[] nums) {
if(null == nums || nums.length == 1){
return true;
}
//递归加缓存
int N = nums.length;
//先手的缓存表
int[][]dp = new int[N][N];
//后手的缓存表
int[][]dp2 = new int[N][N];
//初始化
for(int i = 0;i < N ;i++){
for(int j = 0; j < N ;j++){
dp[i][j] = -1;
dp2[i][j] = -1;
}
}
int f = f2(nums,0,nums.length - 1,dp,dp2);
int g = g2(nums,0,nums.length - 1,dp,dp2);
return f >= g ? true : false;
}
/**
* 先手的递归
* nums 要拿的数组
* left 左边界
* right 右边界
* dp 先手的缓存
* dp2 后手的缓存
*/
public int f2(int[]nums,int left,int right,int[][]dp,int[][]dp2){
//如果缓存里有 直接从缓存中拿
if(dp[left][right] != -1){
return dp[left][right];
}
int ans = 0;
//base case 只剩一个时 归先手
if(left == right){
ans = nums[left];
}else{
int p1 = nums[left] + g2(nums,left + 1,right,dp,dp2);
int p2 = nums[right] + g2(nums,left,right - 1,dp,dp2);
ans = Math.max(p1,p2);
}
//保存答案到缓存中
dp[left][right] = ans;
return ans;
}
/**
* 后手的递归
* nums 要拿的数组
* left 左边界
* right 右边界
* dp 先手的缓存
* dp2 后手的缓存
*/
public int g2(int[]nums,int left,int right,int[][]dp,int[][]dp2){
//如果缓存里有 直接从缓存中拿
if(dp2[left][right] != -1){
return dp2[left][right];
}
int ans = 0;
if(left != right){
int g1 = f2(nums,left + 1,right,dp,dp2);
int g2 = f2(nums,left,right - 1,dp,dp2);
ans = Math.min(g1,g2);
}
dp2[left][right] = ans;
return ans;
}
动态规划
解题思路
代码演示
public boolean PredictTheWinner(int[] nums) {
if(null == nums || nums.length == 1){
return true;
}
return dp(nums);
}
/**
* 动态规划
*/
public boolean dp(int[] nums){
int N = nums.length;
//先手缓存表
int[][]fmap = new int[N][N];
//后手的缓存表
int[][]gmap = new int[N][N];
//根据base case 初始化 先手L == N 时 取数组中的值
//因此直接初始化 L == R 时 等于 nums[i]
//后手方的base case 是0 不需要初始化了，
//因为数组本身就是0
for(int i = 0;i < N ;i++){
fmap[i][i] = nums[i];
}
//开始给缓存表 赋值
for(int i = 1; i < N ;i++){
int R = i;
int L = 0; //行
while(R < N){
int p1 = nums[L] + gmap[L+1][R];
int p2 = nums[R] + gmap[L][R-1];
fmap[L][R] = Math.max(p1,p2);
int g1 = fmap[L+1][R];
int g2 = fmap[L][R-1];
gmap[L][R] = Math.min(g1,g2);
L++;
R++;
}
}
return fmap[0][N - 1] >= gmap[0][N - 1] ? true : false;
}
动态规划专题
零钱兑换,凑零钱问题,从暴力递归到动态规划
数字转字符串,有多少种转化结果
背包问题–填满背包的最大价格
走到指定位置有多少种方式