java算法：动态编程

java算法：动态编程

分治法，简单的说就是把问题分成多个子问题，当子问题不独立时，情况就复杂了。

例1：斐波纳契数列

Java代码

1. staticintf(inti){
2. if(i<1){
3. return0;
4. }
5. if(i==1){
6. return1;
7. }
8. returnf(i-1)+f(i-2);
9. }

static int f(int i){
	if(i < 1){
		return 0;
	}
	if(i == 1){
		return 1;
	}
	return f(i - 1) + f(i - 2);
}

这个程序尽管优美，却并不可用，因为要花指数的时间来计算Fn。Fn+1的计算时间是Fn的约1.6倍。相比之下，子啊线性时间内计算Fn是很容易地：计算前N个斐波纳契数列并把它们存在一个数组中：

Java代码

1. f(0)=0;
2. f(1)=1;
3. for(i=2;i<=N;i++){
4. f(i)=f(i-1)+f(i-2);
5. }

f(0) = 0; 
f(1) = 1;
for(i = 2; i <= N; i++){
	f(i) = f(i - 1) + f(i - 2);
}

数列是成指数增长的，所以数组不大。

这项技术给我们提供了得到任何递归关系式的数值解的直接方法。

递归是值具有整数值的递归函数。从最小值计算这类函数的所有的函数值，在每一部使用先前的计算值来计算当前的值，即称为自底向上的动态编程（记忆法）。如果可以把所有先前的计算值存储起来，则它适用于任何递归计算。必须注意：把算法的运行时间从指数级降低到线性级。

例2：斐波纳契数列（动态编程）

Java代码

1. staticfinalintmaxN=47;
2. staticintknownF[]=newint[maxN];
3. staticintf(inti){
4. if(knownF[i]!=0){
5. returnknownF[i];
6. }
7. intt=i;
8. if(i<0){
9. return0;
10. }
11. if(i>1){
12. t=f(i-1)+f(i-2);
13. }
14. returnknownf[i]=t;
15. }

static final int maxN = 47;
static int knownF [] = new int [maxN];
static int f(int i){
	if(knownF[i] != 0){
		return knownF[i]; 
	}
	int t = i;
	if(i < 0){
		return 0;
	}
	if(i > 1){
		t = f(i - 1) + f(i - 2);
	}
	return knownf[i] = t;
}

通过把计算的值存储在静态数组中，明确避免了任何重复计算。

例3：背包问题（递归实现）

Java代码

1. staticclassItem{
2. intsize;
3. intvalue;
4. }

static class Item{
	int size;
	int value;
}

假设有类型为item的N个项的数组：

Java代码

1. staticintknap(intcap){
2. inti,space,max,t;
3. for(i=0,max=0;i<N;i++){
4. if((space=cap-items[i].size)>=0){
5. if((t=knap(space)+items[i].val)>max){
6. max=t;
7. }
8. }
9. }
10. returnmax;
11. }

static int knap(int cap){
	int i, space, max, t;
	for(i = 0, max = 0; i < N; i++){
		if((space = cap - items[i].size) >= 0){
			if((t = knap(space) + items[i].val) > max){
				max = t;
			}
		}
	}
	return max;
}

例4：背包问题（动态编程）

Java代码

1. staticintknap(intm){
2. inti,space,max,maxi=0,t;
3. if(maxKnown[m]!=unknown){
4. returnmaxKnown[m];
5. }
6. for(i=0,max=0;i<N;i++){
7. if((space=m-items[i].size)>=0){
8. if((t=knap(space)+items[i].val)>max){
9. max=t;
10. maxi=i;
11. }
12. }
13. }
14. maxKnown[m]=max;
15. itemKnown[m]=items[maxi];
16. returnmax;
17. }

static int knap(int m){
	int i, space, max, maxi = 0, t;
	if(maxKnown[m] != unknown){
		return maxKnown[m];
	}
	for(i = 0, max = 0; i < N; i++){
		if((space = m - items[i].size) >= 0){
			if((t = knap(space) + items[i].val) > max){
				max = t;
				maxi = i;
			}
		}
	}
	maxKnown[m] = max;
	itemKnown[m] = items[maxi];
	return max;
}

背包问题的运行时间和MN是成比例的。当容量不大时，可以很容易地解决问题；对于大容量的背包，时间和空间的要求可能过大。

自底向上的动态编程也适用于背包问题。

在自底向上的动态编程中，要预先进行计算。通常更偏好使用自顶向下而不是自底向上的动态编程，因为：是自然解决问题方案的机械转换，子问题的运行顺序估计自身，可能不需要计算所有子问题的答案。自顶向下的动态编程是开发递归算法有效实现的基本技术，是从事算法设计和实现的任何人的必备工具。