动态规划小结（Java）

动态规划(Dynamic programming)
动态规划主要针对最优化问题，他的决策不是线性的而是全面考虑各种不同的情况，分别进行决策，最后通过多阶段决策逐步找出问题的最终解。
当各个阶段采取决策后，会不断决策出新的数据，直到找到最优解。
每次决策依赖于当前的状态，又随机引起状态的转移。所以，这种多阶段最优化决策问题的过程称为动态规划。

一、适用动态规划策略问题的特征：

1）最优子结构性质：一个问题的最优解包含其子问题的最优解，即一个最优化策略的子策略总是最优的。
2）无后向性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说某状态以后的过程不会影响以前的状态，只与当前状态有关
3）子问题重叠：也就是说子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次用到。对于有分解过程的问题还表现在自顶向下分
解问题时，每次产生的子问题并不总是新问题，有些子问题会反复出现。（这个性质不是动态规划使用的必要条件，但是如果不满足该性质，
动态规划算法同其他算法相比就不占优势）

二、动态规划的基本思想：
把求解的问题分成许多阶段或者多个子问题，然后按顺序求解子问题。前一子问题的解，为后一子问题提供有用信息，求解任一子问题是，列出各种可能的局部解，保留有可能达到最优的局部解。依次解决各子问题后，最后一个子问题就是初始问题的解。

三、设计动态规划的基本步骤：

1）分析最优解的性质，刻画其结构特征。
2）递推定义最优值。
3）以自底向上或自顶向下的记忆化方法计算出最优值。
4）根据计算最优值时得到的信息，构造问题的最优解。

例题：
1-1

• 数塔问题

•         9
  

•       12 15
  

•     10  6  8
  

•    2  18  9  5
  

•  19  7  10  4  16   
  

• 从塔顶到底层，每一节点可以向左或向右，找出一条路径是路径上的数值和最大

设计思路，自底向上，每步都进行最优选择arr[i][j] = max(arr[i+1][j] + arr[i][j],arr[i+1][j+1]+arr[i][j])最大的作为本步的解，一次解到arr[0][0]就是最优解。

实现代码

public class NumTower {
	//解决此问题需要自底向上 每步都把最大路径值储存到本步 这样一直到第一个元素就是最大的路径值
	public static int maxPath(int[][] arr) {
		for(int i = arr.length - 2;i>=0;i--) {
			for(int j = 0;j<=i;j++) {
				arr[i][j] = max(arr[i+1][j] + arr[i][j],arr[i+1][j+1]+arr[i][j]);	//选取最大的储存到本步
			}
		}
		return arr[0][0];
	}
	/**
	 * return max of a and b
	 * @param a
	 * @param b
	 * @return
	 */
	public static int max(int a,int b) {
		return a>b?a:b;
	}
	public static void main(String[] args) {
		int[][] tower = new int[5][5];
		tower[0][0] = 9;tower[1][0] = 12;tower[1][1] = 15;
		tower[2][0] = 10;tower[2][1] = 6;tower[2][2] = 8;
		tower[3][0] = 2;tower[3][1] = 18;tower[3][2] = 9;
		tower[3][3] = 5;tower[4][0] = 19;tower[4][1] = 7;
		tower[4][2] = 10;tower[4][3] = 4;tower[4][4] = 16;
		System.out.println(maxPath(tower));
	}
/**
 * output:59
 */
}

1-2 最长公共子序列
给出两个字符串，找到最长公共子序列(LCS)，返回LCS的长度。

最长公共子序列（LCS）是一个在一个序列集合中（通常为两个序列）用来查找所有序列中最长子序列的问题。这与查找最长公共子串的问题不同的地方是：子序列不需要在原序列中占用连续的位置 。

实现代码

public class LongestCommenSubstring {
	
	public static int max(int a,int b) {
		return a>b?a:b;
	}
	/**
	 * 返回a,b最长公共子序列的长度
	 * @param a
	 * @param b
	 * @return
	 */
	public static int[][] getMaxLen(char[] a,char[] b) {
		int[][] c = new int[a.length + 1][b.length + 1];
		for(int i = 1;i<=a.length;i++) {
			for(int j = 1;j<=b.length;j++) {
				if(a[i - 1] == b[j - 1])
					c[i][j] = c[i-1][j-1] + 1;
				else
					c[i][j] = max(c[i][j-1],c[i-1][j]);
			}
		}
		return c;
	}
	/**
	 * 输出最长公共子序列的一种情况
	 * @param a
	 * @param b	
	 * @param c	公共子序列的辅助数组
	 * @param len 公共子序列的长度
	 * @return 公共子序列字符数组
	 */
	public static char[] getPath(char[] a,char[] b,int[][] c,int len) {
		char[] path = new char[len];
		int k = path.length-1,i = a.length,j = b.length;
		while(k>=0) {
			if(c[i][j] == c[i-1][j])
				i--;
			else if(c[i][j] == c[i][j-1])
				j--;
			else {
				path[k] = a[i-1];
				k--;
				j--;
			}
		}
		return path;
	}
	public static void main(String[] args) {
		String a = new String();
		String b = new String();
		Scanner sc = new Scanner(System.in);
		a = sc.nextLine();
		b = sc.nextLine();
		sc.close();
		int[][] temp = getMaxLen(a.toCharArray(),b.toCharArray());
		int len = temp[a.toCharArray().length][b.toCharArray().length];
		System.out.println(temp[a.toCharArray().length][b.toCharArray().length]);
		char[] path = getPath(a.toCharArray(),b.toCharArray(),temp,len);
		for(char x:path) {
			System.out.print(x + " ");
		}
	}
/**
 * input:
 * ABCBDAB
 * BDCABA
 * output:
 * 4
 * B C B A	  
 */
}

1-3 最长上升子序列

最长递增子序列（longest increasing subsequence）问题是指，在一个给定的数值序列中，找到一个子序列，使得这个子序列元素的数值依次递增，并且这个子序列的长度尽可能地大。最长递增子序列中的元素在原序列中不一定是连续的。

实现代码

public class MaxNoSeq {

	public static void main(String[] args) {
		int[] nums = new int[10];
		Scanner sc = new Scanner(System.in);
		for(int i = 0;i<nums.length;i++)
			nums[i] = sc.nextInt();
		sc.close();
		System.out.println("\n"+maxSeq(nums));
	}
	public static int maxSeq(int[] num) {
		int[] len = new int[num.length];
		int[] pre = new int[num.length];
		int max = 0,flag = 0;
		for(int i = 0;i<len.length;i++) {			//每个位置的最大子串最小为1（其自身）
			len[i] = 1;
		}
		for(int i = num.length-2;i>=0;i--) {		//采用后推的方法
			max = 0;
			flag = 0;
			for(int j = i+1;j<num.length;j++) {		//寻找当前位置的最大子串
				if(num[j] > num[i] && len[j]>max) {	//如果后面的大于当前位置
					max = len[j];
					flag = j;
				}
			}
			if(flag!=0) {							//此位置的最大子串等于后一个位置的最大子串长度+1（自身）
				len[i] = len[flag] + 1;
				pre[i] = flag;						//当前位置的后继数组下标
			}
		}
		max = 0;
		for(int i =0;i<len.length;i++) {
			if(max < len[i])
				max = len[i];
		}
		int i = 0;
		while(len[i]!=max)					//找到最大上升子串的首位置
			i++;
		for(;i<len.length;) {
			System.out.print(num[i] + " ");
			i = pre[i];						//让i等于最大子串下一个字符的下标
			if(i == 0)						//不存在下一个数
				break;
		}
		return max;
	}
/**
 * input:3 18 7 14 10 12 23 41 16 24
 * output:
 * 3 7 10 12 23 41 
 * 6
 */
}

1-4 0-1背包问题

给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。

public class Package0_1 {

	public static int maxValue(int[] weight,int[] value,int maxweight) {
		int n = weight.length;	//物品总件数
		int[][] max = new int[n + 1][maxweight+1];
		for(int i = 1;i<n+1;i++) {
			for(int j = 1;j<maxweight+1;j++) {
				if(weight[i-1] <= j) {
					//用放当前物品以后和前一次不放当前物品比较
					if(max[i-1][j - weight[i-1]] + value[i-1] > max[i-1][j])	
						//max[i-1][j-weight[i-1]]+value[i-1]  表示：当将第 i 件物品装入背包时，背包还能承受的重量变成:
						// j-weight[i-1] ,(weight[]数组下标0存储第一件物品的重量)
						max[i][j] = max[i-1][j-weight[i-1]] + value[i-1];
					else
						max[i][j] = max[i-1][j];	
					//否则等于上件的最大重量
				}
				else {										// 第i件物品的重量大于背包的承重
					max[i][j] = max[i-1][j];
					continue;
				}
			}
		}
		return max[n][maxweight];
	}
	public static void main(String[] args) {
		int weight[] = {2,3,4,5};
		int value[] = {3,4,5,7};
		int maxweight = 9;
		System.out.println(maxValue(weight,value,maxweight));
	}
/**
 * output:12
 */
}