01背包问题

问题描述：

有n个重量和价值分别为w(i)和v(i)的物品，放入一个最多能承受W重量的背包里，求背包种物品的最大价值。

备注：我们这里设物品都只有一件。

限制条件：

 1<= n <= 100

1<= w(i),v(i) <= 100

1<= W <=10000

示例：

输入

n = 4 
W = 5
(w, v) = {{2, 3}, {1, 2}, {3, 4}, {2, 2}}

输出

7(选择第0， 1， 3号物品)

递归求解

既然刚开始没思路，那不如我们暴力看一下把！

//递归解决，时间复杂度为O（2^n）
//i为第几号物品，j为剩余重量，初始时调用rec(0, W)
int rec(int i, int j){
    int res;
    if(i == n)//已经没用物品了，递归截至的条件
        res = 0;
    else if(j < w[i])
        res = rec(i + 1, j);//剩余重量放不下，则下一个
    else
        res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);//第i放进去，或者不放进去，取其中较大的一个
    return res;
}

看上去还可以，递归的求解话，最坏的情况每次都需要计算两个分支，那么共有n层复杂度为O（2^n）。emmmmm,貌似有点高，（废话，递归复杂度一般都高）。我决定把递归的过程分析一下（以给出的示例数据），可以看到，【3，2】是被计算了两次的，可以想象，如果数据很多的话，那重复计算所占时间就不是一个小数目。

改进的递归

新增一个数组，把已经计算好的结果记录下来，这样就可以啦。

int dp[MAX_N + 1][MAX_N + 1];//dp数组已经全部赋初值-1
int rec2(int i, int j){
    int res;
    if(dp[i][j] >= 0)//如果已经计算过，则直接使用计算结果
        return dp[i][j];
    else if(i == n)
        res = 0;
    else if(j < w[i])
        res = rec2(i + 1, j);//剩余重量放不下
    else
        res = max(rec2(i + 1, j), rec2(i + 1, j - w[i]) + v[i]);//第i放进去，或者不放进去，取其中较大的一个
    return dp[i][j] = res; 
}

这样处理，复杂度变为了O(nW)(因为最多有n*W种子问题)。看上去好了很多，隔壁acm的lh过来看了一眼，“别用递归，会爆栈的”，额，那看样子只能动态规划了。

动态规划

dp[n][j] = 0;

dp[i][j] = dp[i+1][j]   j < w[i];

dp[i][j] = max(dp[i+1][j], dp[i+1][j - w[i]] + v[i]);

int dpSolve(){
    for(int i = n - 1; i >= 0; i--){
        for(int j = 0; j <= W; j++){
            if(j < w[i])
                dp[i][j] = dp[i+1][j];
            else
                dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i]);
        }
    }
    return dp[0][W];
}