java算法：动态编程

java算法：动态编程

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

例1：斐波纳契数列

Java代码

1. static int f(int i){   
2.     if(i < 1){   
3.         return 0;   
4.     }   
5.     if(i == 1){   
6.         return 1;   
7.     }   
8.     return f(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. static final int maxN = 47;   
2. static int knownF [] = new int [maxN];   
3. static int f(int i){   
4.     if(knownF[i] != 0){   
5.         return knownF[i];    
6.     }   
7.     int t = i;   
8.     if(i < 0){   
9.         return 0;   
10.     }   
11.     if(i > 1){   
12.         t = f(i - 1) + f(i - 2);   
13.     }   
14.     return knownf[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. static class Item{   
2.     int size;   
3.     int value;   
4. }  

static class Item{
	int size;
	int value;
}

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

Java代码

1. static int knap(int cap){   
2.     int i, 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.     return max;   
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. static int knap(int m){   
2.     int i, space, max, maxi = 0, t;   
3.     if(maxKnown[m] != unknown){   
4.         return maxKnown[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.     return max;   
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是成比例的。当容量不大时，可以很容易地解决问题；对于大容量的背包，时间和空间的要求可能过大。

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

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