动态规划 0-1背包问题

动态规划：

设计一个动态规划算法，通常可按照以下几个步骤进行：

(1) 找出最优解的性质，并刻画其结构特征。

(2) 递归地定义最优解的值

(3) 以自底而上的方式计算出最优值

(4) 根据计算最优值时得到的信息，构造一个最优解。

对于一个给定的问题，若具有以下两个性质，则可以考虑用动态规划法来求解。

(1) 最优子结构。如果一个问题的最优解中包含了其子问题的最优解，就说该问题具有最优子结构。当一个问题具有最优子结构时，提示我们动态规划法可能会适用，但是此时贪心策略可能也是适用的。

(2) 重叠子问题。指用来解原问题的递归算法可反复地解同样的子问题，而不是总在产生新的子问题。即当一个递归算法不断地调用同一个问题时，就说该问题包含重叠子问题。此时若用分治法递归求解，则每次遇到子问题都会视为新问题，会极大地降低算法的效率，而动态规划法总是充分利用重叠子问题，对于每个子问题仅计算一次，把解保存在一个在需要时就可以查看的表中，而每次查表的时间为常数。

问题：有n个物品，第i个物品价值为vi，重量为wi，其中vi和wi均为非负数，背包的容量为W，W为非负数。现需要考虑如何选择装入背包的物品，使装入背包的物品总价值最大。该问题以形式化描述如下：

       目标函数为 ：     

       约束条件为：

       满足约束条件的任一集合（x1，x2，...，xn）是问题的一个可行解，问题的目标是要求问题的一个最优解。考虑一个实例，假设n=5，W=17， 每个物品的价值和重量如表9-1所示。可将物品1，2和5装入背包，背包未满，获得价值22，此时问题解为你（1，1，0，0，1）。也可以将物品4和5装入背包，背包装满，获得价值24，此时解为（0，0，0，1，1）。

      下面根据动态规划的4个步骤求解该问题。

(1) 刻画0-1背包问题的最优解的结构。

      可以将背包问题的求解过程看作是进行一系列的决策过程，即决定哪些物品应该放入背包，哪些物品不放入背包。如果一个问题的最优解包含了物品n，即xn=1，那么其余x1，x2，...，x(n-1)一定构成子问题1，2，...，n-1在容量W-wn时的最优解。如果这个最优解不包含物品n，即xn=0，那么其余x1，x2，...，x(n-1)一定构成子问题1，2，...，n-1在容量W时的最优解。

(2)递归定义最优解的值

     根据上述分析的最优解的结构递归地定义问题最优解。设c[i,w]表示背包容量为w时，i个物品导致的最优解的总价值，得到下式。显然要求c[n,w]。

 

(3)计算背包问题最优解的值

java程序实现：

package program;

/***
 * c[i][w]表示背包容量为w时，i个物品导致的最优解的总价值，大小为(n+1)*(w+1) v[i]表示第i个物品的价值，大小为n
 * w[i]表示第i个物品的重量，大小为n
 ***/
public class ZeroAndOneBag {

    void DP(int n, int W, int[][] c, int[] v, int[] wei) {

        for (int i = 1; i <= n; i++) {
            c[i][0] = 0;
            for (int w = 1; w <= W; w++) {
                if (wei[i - 1] > w) // 此处比较是关键 看如果放不进去就设为刚刚的值
                {
                    c[i][w] = c[i - 1][w];
                } else {
                    int temp = c[i - 1][w - wei[i - 1]] + v[i - 1]; // 注意wei和v数组中的第i个应该为wei[i-1]和v[i-1]
                    if (c[i - 1][w] > temp) {
                        c[i][w] = c[i - 1][w];
                    } else
                        c[i][w] = temp;
                }
            }
        }
    }

    void findPath(int[][] c, int[] x, int[] wei, int n, int W) {
        int w = W;
        for (int i = n; i >= 2; i--) {
            if (c[i][w] == c[i - 1][w]) {
                x[i - 1] = 0;
            } else {
                x[i - 1] = 1;
                w = w - wei[i - 1];
            }
        }
        if (c[1][w] == 0)
            x[0] = 0;
        else
            x[0] = 1;
    }

    public static void main(String[] args) {
        ZeroAndOneBag zeroAndOneBag = new ZeroAndOneBag();
        int n = 5;
        int W = 17;
        int[] w = { 3, 4, 7, 8, 9 };
        int[] v = { 4, 5, 10, 11, 13 };
        int[][] c = new int[6][18];

        zeroAndOneBag.DP(n, W, c, v, w);

        System.out.println("最后最大的价值为：" + c[5][17]);
        System.out.println("生成数组的值为：");
        for (int i = 0; i < c.length; i++) {
            for (int j = 0; j < c[0].length; j++) {
                System.out.print(c[i][j] + " ");
            }
            System.out.println("");
        }
        int[] x = new int[5];
        zeroAndOneBag.findPath(c, x, w, n, W);
        for (int i = 0; i < n; i++)
            System.out.print(x[i] + " ");
        System.out.println("");
    }

}

运行结果：

最后最大的价值为：24
生成数组的值为：
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4
0 0 0 4 5 5 5 9 9 9 9 9 9 9 9 9 9 9
0 0 0 4 5 5 5 10 10 10 14 15 15 15 19 19 19 19
0 0 0 4 5 5 5 10 11 11 14 15 16 16 19 21 21 21
0 0 0 4 5 5 5 10 11 13 14 15 17 18 19 21 23 24
0 0 0 1 1

 

上述代码的时间复杂度为O(nw)。

c[i][w]矩阵如下表所示：

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4
0 0 0 4 5 5 5 9 9 9 9 9 9 9 9 9 9 9
0 0 0 4 5 5 5 10 10 10 14 15 15 15 19 19 19 19
0 0 0 4 5 5 5 10 11 11 14 15 16 16 19 21 21 21
0 0 0 4 5 5 5 10 11 13 14 15 17 18 19 21 23 24

(4)根据计算的结果，构造问题最优解。

     根据上一步计算的c数组，很容易构造问题的最优解。判断c[i,w]与c[i-1,w]的值是否相等，若相等，则说明xi=0，否则为1。具体代码在3中。

 

这种方法有一定的好处，能够消除递归，还能直观的得出findpath()的结果

递归实现DP

int dp(int n, int W, int *v, int *wei)
{
    if (n == 0 || W == 0)
        return 0;
    else if (wei[n - 1] > W)
        return dp(n - 1, W, v, wei);
    else
    {
        int valueA = dp(n - 1, W - wei[n - 1], v, wei) + v[n - 1];
        int valueB = dp(n - 1, W, v, wei);
        return valueA > valueB ? valueA : valueB;
    }
}

 参考：http://blog.csdn.net/yeepom/article/details/8712224