动态规划A-1

动态规划是对暴力“递归算法”的优化，主要是通过数组记录的方法，优化掉一些重复计算的过程。动态规划强调 自然智慧 的应用。

递归分析问题是抽象的，所以再分析问题时不要过于细节。

动态规划的过程：

(1)尝试。抽象出一种"尝试的办法"，递归解决问题的办法很重要。

(2)找到试法中的可变参数，规划成数组表，可变参数一般是0维的，有几个可变参数就是几维的表。

(3)找到基础解法，问题最基础的解填入数组表中。

(4)根据试法中的递归过程，和基础解法已经填到数组表的值，继续填表。

(5)根据问题给定的参数，找到数组中的对应位置，就是最终的解。

---

例题【2】排成一条线的纸牌博弈问题。

给定一个整型数组Arr,代表数值不同的纸牌排成一条线，玩家A和玩家B依次拿走每张纸牌，规定玩家A先拿，玩家B后拿，但是两个玩家均绝顶聪明，请返回最后获胜者的分数。

分析：列举几种错了的尝试思路：

1.玩家每次都会拿左右两个比较后更大的数。但是前者拿完还要考虑对家怎么拿，简言之：拿完这步还要算计下一步，下下一步……。

2.从牌的角度考虑，牌决定输赢。那么先拿的人一定会赢。虽然先拿的人更有优势。但玩家不能保证每次自己都是先拿，所以优势在双方这里交替，来来回回中，结果不可料。

3.我们得写出一个能赢的策略。题目中已说明，玩家绝顶聪明，我们似乎没法能模拟“绝顶聪明”。

这几种错误的理解都可以通过举个例子模拟一下题意实现。

如何分析一个动态规划问题？

首先你看到这个题目不一定知道这是动态规划问题。题目描述的很抽象。没有很清晰的操作步骤。所以这种问题就得用抽象的分析方法，题目越抽象，越接近一个口头的脑筋急转玩而且越没有具体体现很多明显的细节操作时（即越抽象），我们思考上越要向递归靠拢。

分析用递归解题时，我们可以想：什么时可以反复使用？且操作上下步有什么基本的联系呢？这个问题就是最接近递归底层的发问。

这时候我们就使劲琢磨题中的几句话。因为题干很少说废话，说了就是这个因素非常重要，将会影响到最后的结果。玩家A先拿，B后拿。这个问题提醒我们先后手问题。对于绝顶聪明这句话的理解是：两个人都会做出当时状态下的最优选择，不考虑策略因素影响。先手和后手有啥不一样？先手可以选择更有利的情况。

我们以“ 5，7，9，2”这组数为例。

首先我们分析参数。

（1）描述数组的，数组左边界L（0，length-1），数组右边界R（0，length-1），数组长度length

（2）题目问什么，我们应该怎么设计这个返回值？首先这是个不断的选择然后累加上选择值的操作，最后返回赢家分数。而且我们应该针对A,B两个主体。要么就是整俩变量不断覆盖，要么就是用对应俩表记录。

//递归解法下的：第一代

//先手函数
int f(int[] arr,int i,intj)
{
 if(i=j)  return arr[i];
 return Math.max(arr[i]+g(arr,i+1,j)+arr[j]+g(arr,i,j-1));
//先手做出当下最有利的选择
}
//后手函数
int g(int[]arr,int i,int j)
{
  if(i==j)  return 0;
  return Math.min(f(arr,i+1，j),f(arr,i,j-1));
}  //做出最坏的选择（这点是相对先手做出最优选择而言后手就被迫处于最坏的选择中）

//暴力递归版本
public class Code02_CardsInLine{
    //根据规则，返回获胜者的分数
    public static int win(int[] arr)
    {
        if(arr==null||arr.length==0)
        {
            return 0;//大前提的边界
        }
        //研究对象人的两种状态
        int first=f1(arr,0,arr.length-1);
        int second=g1(arr,0,arr.length-1);
        return Math.max(first,second);
    }
    //arr[L。。。先手获得最好的分数返回]
    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);//返回题目的问题：赢家的分数
    }
    //arr[L...R]后手以最好的分数返回
    public static int g1(int[]arr,int L,int R)
    {
        if(L==R)
        {
            return 0;
        }
        int p1=f1(arr,L+1,R);//对手拿走了L位置的数+上把先手的分数
        int p2=f1(arr,L,R-1);
        return Math.min(p1,p2);//力求最优
    }
    public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 5, 8, 1, 6, 0, 3, 4, 6, 1, 7 };
		System.out.println(win1(arr));
		System.out.println(win2(arr));
		System.out.println(win3(arr));
	}
}

 

 我们来分析一下这里的图解：

1.它们时间逻辑顺序是：递归题意分析-->递归树形图-->递推式-->缓存逻辑推理图-->缓存图表

2.缓存逻辑推理图也叫做DP图，体现着参数的位置依赖关系，通过位置依赖关系可以再进行优化。   

对于递推式，一般我们用于对代码的检验。

树形图可以在分析环节中使用。

//动态优化后的先手函数：第三代
// arr[L..R]，先手获得的最好分数返回
	public static int f2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
		if (fmap[L][R] != -1) {
			return fmap[L][R];// 缓存表存过就不会再取值
		}
		int ans = 0;
		if (L == R) {
			ans = arr[L];
		} else {
			int p1 = arr[L] + g2(arr, L + 1, R, fmap, gmap);
			int p2 = arr[R] + g2(arr, L, R - 1, fmap, gmap);
			ans = Math.max(p1, p2);
		}
		fmap[L][R] = ans;
		return ans;
	}

本题是从左到右模型。

  public static int win2(int[] arr) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		int N = arr.length;
		int[][] fmap = new int[N][N];
		int[][] gmap = new int[N][N];
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				fmap[i][j] = -1;
				gmap[i][j] = -1;
			}
		}
		int first = f2(arr, 0, arr.length - 1, fmap, gmap);
		int second = g2(arr, 0, arr.length - 1, fmap, gmap);
		return Math.max(first, second);
	}

//动态规划版本
public class CardsInLine {
	// arr[L..R]，先手获得的最好分数返回,同时我们添加了gmap表的缓存
	public static int f2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
		if (fmap[L][R] != -1) {
			return fmap[L][R];
		}
		int ans = 0;
		if (L == R) {
			ans = arr[L]; //basecase 剩最后一张
		} else {
			int p1 = arr[L] + g2(arr, L + 1, R, fmap, gmap);
			int p2 = arr[R] + g2(arr, L, R - 1, fmap, gmap);
			ans = Math.max(p1, p2);
		}
		fmap[L][R] = ans;
		return ans;
	}

  // arr[L..R]，后手获得的最好分数返回
	public static int g2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
		if (gmap[L][R] != -1) {
			return gmap[L][R];
		}
		int ans = 0;
		if (L != R) {
			int p1 = f2(arr, L + 1, R, fmap, gmap); // 对手拿走了L位置的数
			int p2 = f2(arr, L, R - 1, fmap, gmap); // 对手拿走了R位置的数
			ans = Math.min(p1, p2);
		}
		gmap[L][R] = ans;
		return ans;
	}

	public static int win3(int[] arr) {
		if (arr == null || arr.length == 0) {
			return 0;    //边界条件
		}
		int N = arr.length; 
		int[][] fmap = new int[N][N];
		int[][] gmap = new int[N][N];//建立先手和后手的缓存表
		for (int i = 0; i < N; i++) {
			fmap[i][i] = arr[i];
		}
		for (int startCol = 1; startCol < N; startCol++) {
			int L = 0;
			int R = startCol;
			while (R < N) {
				fmap[L][R] = Math.max(arr[L] + gmap[L + 1][R], arr[R] + gmap[L][R - 1]);
				gmap[L][R] = Math.min(fmap[L + 1][R], fmap[L][R - 1]);
				L++;
				R++;
			}
		}
		return Math.max(fmap[0][N - 1], gmap[0][N - 1]);
	}

	public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 5, 8, 1, 6, 0, 3, 4, 6, 1, 7 };
		System.out.println(win1(arr));
		System.out.println(win2(arr));
		System.out.println(win3(arr));
	}
};