java动态编程_java算法：动态编程

java算法：动态编程

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

例1：斐波纳契数列

Java代码

staticintf(inti){

if(i <1){

return0;

}

if(i ==1){

return1;

}

returnf(i -1) + f(i -2);

}

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代码

f(0) =0;

f(1) =1;

for(i =2; i <= N; i++){

f(i) = f(i -1) + f(i -2);

}

f(0) = 0;

f(1) = 1;

for(i = 2; i <= N; i++){

f(i) = f(i - 1) + f(i - 2);

}

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

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

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

例2：斐波纳契数列(动态编程)

Java代码

staticfinalintmaxN =47;

staticintknownF [] =newint[maxN];

staticintf(inti){

if(knownF[i] !=0){

returnknownF[i];

}

intt = i;

if(i <0){

return0;

}

if(i >1){

t = f(i -1) + f(i -2);

}

returnknownf[i] = t;

}

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代码

staticclassItem{

intsize;

intvalue;

}

static class Item{

int size;

int value;

}

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

Java代码

staticintknap(intcap){

inti, space, max, t;

for(i =0, max =0; i 

if((space = cap - items[i].size) >=0){

if((t = knap(space) + items[i].val) > max){

max = t;

}

}

}

returnmax;

}

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代码

staticintknap(intm){

inti, space, max, maxi =0, t;

if(maxKnown[m] != unknown){

returnmaxKnown[m];

}

for(i =0, max =0; 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];

returnmax;

}

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是成比例的。当容量不大时，可以很容易地解决问题；对于大容量的背包，时间和空间的要求可能过大。

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

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