整理一下各种背包问题：01背包，完全背包，填满背包，带负数的背包

前言

发现自己不知第几次搜背包问题的相关知识点了，决定自己整理一下，好记性不如烂笔头。

01背包

问题：有n件物品，第i件物品的价值是v[i]，重量是w[i]，背包的容量是c，问能装下的最大价值是多少？

我们令dp[i][j]表示前i件物品放到容量为j的背包中的最大价值，则可以对第i件物品分情况讨论，若不放第i件物品，则dp[i][j]等于dp[i-1][j]，若放第i件物品，首先要满足j大于w[i]，此时的dp[i][j]等于dp[i-1][j-w[i]]+v[i]，取两者中的较大值即可。

代码

public int Knapsack01(int[] v, int[] w, int c) {
    int n = v.length;
    int[][] dp = new int[n+1][c+1]; 
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j <= c; j++) {
            dp[i][j] = dp[i-1][j];
            if(j >= w[i-1]) {
                dp[i][j] = Math.max(dp[i][j], dp[i-1][j-w[i-1]] + v[i-1]);
            }
        }
    }
    return dp[n][c];
}

当然了，发现每次迭代都仅需要上一行的结果，而非全部的结果，因此可继续进行空间的优化。

由于计算需要左边的数据，因此可以从右往左遍历，防止左边的数据被修改。

public int Knapsack01Optimized(int[] v, int[] w, int c) {
    int n = v.length;
    int[] dp = new int[c+1];
    for(int i = 0; i < n; i++) {
        for(int j = c; j >= 0; j--) {
            if(j >= w[i]) {
                dp[j] = Math.max(dp[j], dp[j-w[i]] + v[i]);
            }
        }
    }
    return dp[c];
}

完全背包

问题：有n种物品，每种物品有无数件，第i种物品的价值是v[i]，重量是w[i]，背包的容量是c，问能装下的最大价值是多少？

我们令dp[i][j]表示前i件物品放到容量为j的背包中的最大价值，则可以对第i种物品分情况讨论，若不放第i种物品，则dp[i][j]等于dp[i-1][j]，若放第i种物品，需要讨论放多少件，假设放k件，则dp[i][j] 等于dp[i-1][j-k*w[i]] + k*v[i]，遍历k的值，最大的结果就是dp[i][j]的值。

public int CompleteKnapsack(int[]v, int[] w, int c) {
    int n = v.length;
    int[][] dp = new int[n+1][c+1];
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j <= c; j++) {
            for(int k = 0; k * w[i-1] <= j; k++) {
                dp[i][j] = Math.max(dp[i][j], dp[i-1][j-k*w[i-1]] + k*v[i-1]);
            }
        }
    }
    return dp[n][c];
}

同样可以优化空间复杂度：

public int CompleteKnapsackOptimized(int[]v, int[] w, int c) {
    int n = v.length;
    int[] dp = new int[c+1];
    for(int i = 0; i < n; i++) {
        for(int j = c; j >= 0; j--) {
            for(int k = 0; k * w[i] <= j; k++) {
                dp[j] = Math.max(dp[j], dp[j-k*w[i]] + k*v[i]);
            }
        }
    }
    return dp[c];
}

限制物品数量

问题：有n种物品，第i种物品的数量是q[i]，价值是v[i]，重量是w[i]，背包的容量是c，问能装下的最大价值是多少？

与完全背包类似，只不过这里最内层的循环范围为[0,q[i]]。

public int CompleteKnapsack(int[] q, int[]v, int[] w, int c) {
    int n = v.length;
    int[][] dp = new int[n+1][c+1];
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j <= c; j++) {
            for(int k = 0; k <= q[i-1] && k * w[i-1] <= j; k++) {
                dp[i][j] = Math.max(dp[i][j], dp[i-1][j-k*w[i-1]] + k*v[i-1]);
            }
        }
    }
    return dp[n][c];
}

优化空间不再赘述。

填满背包

问题：有n种物品，每种物品有无数件，第i种物品的价值是v[i]，重量是w[i]，背包的容量是c，问在填满背包的前提下能装下的最大价值是多少？

其实也和上面类似，只不过对于没有填满的情形，我们标记价值为-1，在迭代时注意处理一下就好了。

我们令dp[i][j]表示前i件物品放到容量为j的背包中的最大价值，则可以对第i种物品分情况讨论，若不放第i种物品，则dp[i][j]等于dp[i-1][j]，若放第i种物品，需要讨论放多少件，假设放k件，若dp[i-1][j-k*w[i]]等于-1，则dp[i][j]等于-1，若dp[i-1][j-k*w[i]]不等于-1，则dp[i][j] 等于dp[i-1][j-k*w[i]] + k*v[i]，遍历k的值，最大的结果就是dp[i][j]的值。

public int KnapsackCramed(int[]v, int[] w, int c) {
    int n = v.length;
    int[][] dp = new int[n+1][c+1];
    for(int[]i : dp) {
        Arrays.fill(i, -1);
    }
    for(int i = 0; i <= n; i++) {
        dp[i][0] = 0;
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j <= c; j++) {
            for(int k = 0; k * w[i-1] <= j; k++) {
                int temp = dp[i-1][j-k*w[i-1]];
                dp[j] = Math.max(dp[j], temp == -1 ? -1 : temp + k*v[i-1]);
            }
        }
    }
    return dp[n][c];
}

优化后不仅空间复杂度降低了，代码也简洁了。

public int KnapsackCramedOptimized(int[]v, int[] w, int c) {
    int n = v.length;
    int[] dp = new int[c+1];
    Arrays.fill(dp, -1);
    dp[0] = 0;
    for(int i = 0; i < n; i++) {
        for(int j = c; j >= 0; j--) {
            for(int k = 0; k * w[i] <= j; k++) {
                int temp = dp[j-k*w[i]];
                dp[j] = Math.max(dp[j], temp == -1 ? -1 : temp + k*v[i]);
            }
        }
    }
    return dp[c];
}

带负数的背包

问题：有n件物品，第i件物品的价值是v[i]，重量是w[i]，背包的容量是c，问能装下的最大价值是多少？注意，有些物品的价值或重量为负数。

其实也是01背包问题，只不过要注意的是容量和价值会出现负数，并且递推中间结果时可能会出现容量为负或者容量大于背包容量的情形。因此实际上我们可以做一个平移，令dp[i][j]表示前i种物品放到容量为j-10000的背包中的最大价值，避免出现负索引（当然这里10000是随便取的，实际取时要参考背包可能出现的最小的负容量是多少）。

太难了，还没想明白，下次再写吧=-=