动态规划-排成一条线的纸牌博弈等问题

有一个整型数组A，代表数值不同的纸牌排成一条线。玩家a和玩家b依次拿走每张纸牌，规定玩家a先拿，玩家B后拿，但是每个玩家每次只能拿走最左或最右的纸牌，玩家a和玩家b都绝顶聪明，他们总会采用最优策略。请返回最后获胜者的分数。
给定纸牌序列A及序列的大小n，请返回最后分数较高者得分数(相同则返回任意一个分数)。保证A中的元素均小于等于1000。且A的大小小于等于300。
测试样例：
[1,2,100,4],4
返回：101
用暴力递归的方法：

定义递归函数f(i,j),表示如果arr[i...j]这个排列上的纸牌被绝顶聪明的人拿走，最终能够获得什么分数。

定义递归函数s(i,j),表示如果a[i..j]这个排列上的纸牌被绝顶聪明的人后拿，最终能获得什么分数。
首先来分析，具体过程如下：
1.如果i==j(只有一张纸牌)，会被先拿纸牌的人拿走，所以返回arr[i];
2.如果i!=j,先拿纸牌的人有两种选择，要么拿走arr[i],要么拿走arr[j];
如果拿走arr[i],剩下arr[i+1,j]。对于arr[i+1,j]的纸牌，当前玩家成了后拿的人，因此他后续能获得的分数为s(i+1,j).如果拿走arr[j],那么剩下arr[i,j-1],当前玩家后续能获得的分数为s[i,j-1],作为绝顶聪明的人，必然会在两种决策中选择最优的。所以返回max{arr[i]+s[i+1,j],arr[j]+s[i][j-1]}
然后来分析s(i,j):
1.如果i==j,后拿纸牌的人什么也拿不到，返回0
2.如果i!=j,玩家的对手会先拿纸牌。对手要么先拿走a[i],要么先拿走arr[j],如果对手拿走arr[i],那么排列剩下arr[i+1,j],如果对手拿走arr[j],剩下arr[i,j-1],对手也是绝顶聪明的人，所以也会把最差的情况留给玩家因此返回min{f(i+1,j),f(i,j-1)}
解法一：public int cardGame(int[] arr, int n) {

if(arr==null||n==0){return 0;}

return Math.max(f(arr,0,n-1),s(arr,0,n-1)); // write code here

}

public int f(int[]arr,int start,int end){

if(start==end){return arr[start];}

return Math.max(arr[start]+s(arr,start+1,end),arr[end]+s(arr,start,end-1));

}

public int s(int[]arr,int start,int end){

if(start==end){return arr[start];}

return Math.min(f(arr,start+1,end),f(arr,start,end-1));

}

解法二：public int cardGame(int[] arr, int n) {

if(arr==null||arr.length==0){return 0;}

int[][] f=new int

;

int[][] s=new int

;

for(int j=0;j<arr.length;j++){

f[j][j]=arr[j];

for(int i=j-1;i>=0;i--){

f[i][j]=Math.max(arr[j]+s[i][j-1],arr[i]+s[i+1][j]);
//f[i][j]表示在arr[i...j]区间内当前玩家最大的累加和

s[i][j]=Math.min(f[i+1][j],f[i][j-1]); //s[i][j]表示在arr[i..j]区间内的最小累加和

}

}

return Math.max(f[0][n-1], s[0][n-1]);

}

第一个玩家每次会保证自己是本次和另一个玩家取完最大值后再取剩下的的和最大f[i][j]就记录最大值即Math.max(arr[j]+s[i][j-1],arr[i]+s[i+1][j]);

对于另一个玩家来说，会取第一个玩家取完剩下的较大的数，对于第一个玩家来说就是没取数之前较小的即Math.min(f[i+1][j],f[i][j-1]);

换钱的方法数:

给定数组arr,arr中所有的值都为正数且不重复，每个值代表一种面值的货币，每种面值的货币可以使用任意张，在给定一个数组aim代表要找的钱数，求换钱有多少种方法

暴力递归的方法。arr[5,10,25,1],aim=1000,分析过程如下：

1.用0张5元的，让其余的组成1000，

2.用1张5元的，其余的组成995

3.用2张5.。。

其余的又用0张，一张。。。将所有的张数加起来就是最后的结果。

解法一：暴力递归法：

public int coins(int[] arr,int aim){

if(arr==null||arr.length==0||aim<0){return 0;}

return proccess(arr,0,aim);

}

public int process(int[] arr,int index,int aim){

int res=0;//初始化方法数

if(index==arr.length){res=aim==0?1:0;}

else {

for(int i=0;arr[index]*i<=aim;i++){

res+=process(arr,index+1,aim-arr[index]*i);//依次递归剩下的钱的组成方案数

}

}

return res;

}

解法二：记忆化搜索：

用一个map数组保存上一次计算出的中间值，map[i][j]表示递归过程p(i,j)的返回值。

map[i][j]=0,表示递归过程未计算过，map[i][j]=-1表示递归过程计算过，但结果为0，其他情况时则保存递归过程的值。

public int coins(int[] arr,int aim){

if(arr==null||arr.length==0||aim==0){return 0;}

int[][] map=new int[arr.length+1][aim.length+1];

return process(arr,0,aim,map);

}

public int process(int[] arr,int index,int aim,int[][] map){

int res=0;

if(index==arr.length){res=aim==0?1:0;}

else{

int mapvalue=0;

for(int i=0;arr[index]*i<=aim;i++){

mapvalue=map[index+1][aim-arr[index]*i];

if(mapvalue!=0){res+=mapvalue==-1?0:mapvalue;}

else{

res+=process(arr,index+1,aim-arr[index]*i,map);

}

}

}

map[index][aim]=res==0?-1:res;

return res;

}

解法三：生成行数N，列数aim+1的矩阵dp,dp[i][j]的含义是在使用arr[0...i]的货币的情况下，组成钱数j有多少种方法。

1.对于矩阵dp的第一列dp[...][0],表示组成钱数为0的方法数，一种，很明显就是不使用任何货币，所以dp的值为1.

2.对于矩阵dp的第一行的值dp[0][...],表示只能使用arr[0]的情况下，组成钱的方法数dp[i][k*arr[0]]=1

3.除第一行和第一列的其他位置，dp[i][j]是以下几个情况的累加和

完全不用arr[i]货币，剩下的钱用arr[0..i]组成时，方法数为dp[i-1][j]

用一个arr[i]货币，剩下的钱用arr[0..i]组成，方法数为dp[i-1][j-arr[j]*i]

最终dp[i][j]就是最终结果。

public int coins(int[] arr,int aim){

if(arr==null||arr.length==0||aim<0){return 0;}

int[][] dp=new int[arr.length][aim+1];

for(int i=0;i<arr.length;i++){dp[i][0]=1;}//初始化第一行

for(int j=1;j<arr[0]*j<=aim;j++){dp[0][arr[0]*j]=1;}

for(int i=1;i<arr.length;i++){

for(int j=1;j<=aim;j++){

//遍历每种情况求结果数

int res=0；//当用arr[0..i]时。组成j的方法数。

dp[i][j]=dp[i-1][j];

dp[i][j]+=j-arr[i]>=0?dp[i][j-arr[i]]:0;

}

}

return dp[arr.length-1][aim];

}

以上方法的时间复杂度O(N*aim),空间复杂度O(aim);

再将空间压缩，得到空间复杂度O(aim)的算法

public int coins(int[] arr,int aim){

if(arr==null||arr.length==0||aim<0){return 0;}

int[] dp=new int[aim+1];

for(int i=0;arr[0]*j<=aim;j++){dp[arr[0]*j]=1;}

for(int i=1;i<arr.length;i++){

for(int j=1;j<=aim;j++){dp[i]+=j-arr[i]>=0?dp[j-arr[i]]:0;}

}

return dp[aim];

}

跳跃游戏

给定数组arr,arr[i]==k,代表从位置i向右跳跃1~k个距离。比如arr[2]==3,代表从位置2可以跳到位置3，位置4，位置5。如果从位置0出发，返回最少跳几次能够跳到arr最后的位置上。

从左到右遍历arr,假设遍历到位置i,

如果cur大于=i,说明条jump步可以到达位置i，

如果cur小于i,说明不能够到大位置，需要多跳一步才行

public jump(int[] arr){

if(arr==null||arr.length==0){return 0;}

int jump=0;

int cur=0;

int next=0;

for(int i=0;i<arr.length;i++){

if(cur<i){jump++;cur=next;}//可以到达

next=Math.max(next,i+arr[i]);//将next更新，表示下一跳多跳一步到达的最远位置

}

return jump;

}