算法进阶-动态规划

经典例题

大家肯定想用递归做
思路大概就是这样
递归到最后一行就是对应的D(i,j)
然后往上推

但是这样会超时，因为存在大量的重复计算
比如调用第一行MasSum(7)需要调用MaxSum(3)和MaxSum(8)
但是调用第二行MaxSum(3)还要调用3行的MaxSum(8)和3行的MaxSum(1)
第二行的MaxSum(8)也会调用第三行的MaxSum(1)
是不是第三行的MaxSum(1)就调用了两次
这就重复了
随着数据量增多，重复也会增多

改进前代码

import java.util.Scanner;


public class Main {

public static void main(String[] args) {

	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();
	int a[][]=new int[n][n];
	int b[][]=new int[n][n];
	for (int i = 0; i < b.length; i++) {
		for (int j = 0; j <=i; j++) {
			a[i][j]=sc.nextInt();
		}
	}
	System.out.println(Max(a, b, 0, 0));

}
public static int Max(int [][]a,int [][]b,int x,int y) {
	
	if(x==a.length-1)
		return a[x][y];
	else 
	return Math.max(Max(a, b, x+1, y), Max(a, b, x+1, y+1))+a[x][y];
}
}

改进

算出来的数存起来，再调用直接取就行，避免重复计算
程序代码

so：在算法中避免重复计算来提高算法效率就是动态规划

改进后代码

import java.util.Scanner;


public class Main {

public static void main(String[] args) {

	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();
	int a[][]=new int[n][n];
	int b[][]=new int[n][n];
	for (int i = 0; i < b.length; i++) {
		for (int j = 0; j <=i; j++) {
			a[i][j]=sc.nextInt();
		}
	}
	System.out.println(Max(a, b, 0, 0));

}
public static int Max(int [][]a,int [][]b,int x,int y) {
	if(b[x][y]!=0) {
		return b[x][y];//如果有对应的就不用算了，直接返回
	}
	
	if(x==a.length-1)
		b[x][y]=a[x][y];//就是把所有得到的结果不是直接返回了，先存起来
	else {
	b[x][y]=Math.max(Max(a, b, x+1, y), Max(a, b, x+1, y+1))+a[x][y];//这个也是赋值
	}
	return b[x][y];
}
}
  

递推解法

其实一般能用递归的也可以用循环
可能循环比较多
也可能是循环比较难推
这个就需要我们从下面往上推所以
你从上往下推不出来

递推解法
从最底层开始递推

i=a.length-2到0
j从0到i
一个个推可以用循环来
a[i][j]=Math.max(a[i][j]+a[i+1][j],a[i][j]+a[i+1][j+1])
最后的a[0][0]就是得数

一般思路

先讲答案枚举一些（或全部）
画出一个二叉树-尝试写一个递归函数来求解
如果发现有大量的重复计算
可以用动态规划-可以用数组或者哈希表进行存储

最终可以找规律写成迭代形式（循环）
(或者说把return的储存在一个数据结构中需要的时候取出来)

适用题型

上升序列

题目
题目描述
一个数的序列bi，当b1<b2<...<bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1,a2,...,aN)，我们可以得到一些上升的子序列(ai1,ai2,...,aiK)，这里1≤i1<i2<...<iK≤N。比如，对于序列(1,7,3,5,9,4,8)，有它的一些上升子序列，如(1,7),(3,4,8)等等。这些子序列中最长的长度是4，比如子序列(1,3,5,8)。
你的任务，就是对于给定的序列，求出最长上升子序列的长度。

输入
输入的第一行是序列的长度N(1≤N≤1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000。
输出
最长上升子序列的长度。
样例输入
7
1 7 3 5 9 4 8
样例输出
4

更改前代码

import java.util.ArrayList;
import java.util.Scanner;

@SuppressWarnings("all")
public class Main {

public static void main(String[] args) {

	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();
	int []a =new int[n];
	int []b =new int[n];
	for (int i = 0; i < a.length; i++) {
		a[i]=sc.nextInt();
	}
	for (int i = 0; i < b.length; i++) {
		b[i]=1;
	}
	ArrayList<Integer> arrayList = new ArrayList<Integer>();
	for (int i = 0; i < b.length; i++) {
		arrayList.add(l(a, i));
	}
	
	arrayList.sort(new Comparator<Integer>() {

		@Override
		public int compare(Integer o1, Integer o2) {
			// TODO Auto-generated method stub
			return o2-o1;
		}
	});
	System.out.println(arrayList.get(0));
}
public static int l(int []a,int i) {
	int Max=1;
	for (int j = i+1; j < a.length; j++) {
		if(a[j]>a[i])
			Max=Math.max(l(a,j)+1, Max);
		
	}
	return Max;
	
	
}
}

更改后的代码

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

@SuppressWarnings("all")
public class Main {

public static void main(String[] args) {

	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();
	int []a =new int[n];
	int []b =new int[n];
	for (int i = 0; i < a.length; i++) {
		a[i]=sc.nextInt();
	}
	for (int i = 0; i < b.length; i++) {
		b[i]=-1;
	}
	ArrayList<Integer> arrayList = new ArrayList<Integer>();
	for (int i = 0; i < b.length; i++) {
		arrayList.add(l(a, i, b));
	}
	
	arrayList.sort(new Comparator<Integer>() {

		@Override
		public int compare(Integer o1, Integer o2) {
			// TODO Auto-generated method stub
			return o2-o1;
		}
	});
	System.out.println(arrayList.get(0));
}
public static int l(int []a,int i,int b[]) {//加一个参数b[i]存储Max
	if(b[i]!=-1)//刚开始就判断，如果有就不要重复计算直接返回
		return b[i];
	int Max=1;
	for (int j = i+1; j < a.length; j++) {
		if(a[j]>a[i])
			Max=Math.max(l(a,j,b)+1, Max);
		
	}
	b[i]=Max;
	return Max;
	
	
}
}
   

递推

这个也算从末位来递推可以找规律
只要是不从头的递推基本上都可以从尾部递推
代码差不多是这样