预测赢家

leetcode 486 题
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/predict-the-winner

题目描述

给你一个整数数组 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

暴力递归

解题思路

首先考虑先手方:
因为只能从左边或者右边拿,那么每次出手就有两种选择,
再考虑后手方:
后手拿牌只能从先手拿过的之后的里面去选，因此也要考虑先手拿的左边还是右边。
先手拿过以后，就归后手拿，因此这个递归就应该写成嵌套的递归。
后手也同理

代码演示

 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);
    }

暴力递归 + 缓存

解题思路

在暴力递归中，有两个变量在一直变换，
left 和 right .递归时会有很多重复的情况。
我么用缓存把这两个的变化，缓存起来
重复时，直接从缓存里取。

代码演示

 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;
    } 

动态规划

解题思路

动态规划就是对递归的改写，把递归过程，改成缓存表的填值过程
一.根据bace case 初始化缓存表
二.根据递归的过程去把缓存表中的值上
三.填好值后，要取的值就是递归调用的最初始过程

代码演示

 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;
    }

动态规划专题

零钱兑换,凑零钱问题,从暴力递归到动态规划

数字转字符串,有多少种转化结果

背包问题–填满背包的最大价格

走到指定位置有多少种方式