java算法：动态编程

java算法：动态编程

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

例1：斐波纳契数列

static int f(int i){
    if(i < 1){
        return 0;
    }
    if(i == 1){
        return 1;
    }
    return f(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个斐波纳契数列并把它们存在一个数组中：

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：斐波纳契数列（动态编程）

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;
}

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：背包问题（递归实现）

static class Item{
    int size;
    int value;
}

static class Item{
	int size;
	int value;
}

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

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;
}

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：背包问题（动态编程）

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;
}

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

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

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