动态规划-01背包问题

1、问题描述

给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包容量为c。问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大。在选择装入背包的物品时，对每种物品i只有两种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。因此，该问题称为0-1背包问题。

2、算法分析

0-1背包问题的最优子结构，设(y1,y2,...,yn)是所给0-1背包问题的一个最优解，则(y2,y3,...,yn)是经过一次选择后的0-1背包问题的最优解。0-1背包问题的递归关系，设当前子问题的最优值为p[i][j]，即p[i][j]表示前i个物品能装入载重量为j的背包中的最大价值。由0-1背包问题的最优子结构性质，可以建立计算p[i][j]的递归式：
若w[i]>j，第i个物品不装入背包；

否则，若w[i]<=j且第i个物品装入背包后的价值>p[i-1][j]，则记录当前最大价值（替换为第i个物品装入背包后的价值）。

计算最大价值的动态规划算法：

for (i = 1; i < weight.length; i++) {
            for (j = 1; j < max+1; j++) {
                //weight[i]>j,第i个物品不装入背包
                p[i][j] = p[i - 1][j];
                //weight[i]<=j,且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值
                int temp;
                if(j >=weight[i])
                {
                    temp = p[i - 1][j - weight[i]] + value[i];
                    if (temp > p[i][j])
                        p[i][j] = temp;
                }
            }
        }

即该段程序完成以下n个阶段：

1：只装入1个物品，确定在各种不同载重量的背包下，能够得到的最大价值；

2：装入2个物品，确定在各种不同载重量的背包下，能够得到的最大价值；

。。。

n：以此类推，装入n个物品，确定在各种不同载重量的背包下，能够得到的最大价值。

确定装入背包的具体物品，从p[n][max]向前逆推：

若p[n][max]>p[n-1][max]，则第n个物品被装入背包，且前n-1个物品被装入载重量为max-w[n]的背包中

否则，第n个物品没有装入背包，且前n-1个物品被装入载重量为max的背包中

以此类推，直到确定第一个物品是否被装入背包为止。逆推代码如下：

for (int i = len-1; i >0; i--) {
        if(p[i-1][temp]<p[i][temp])
        {
            selection[i] = true;
            temp-=weight[i];
        }
    }

3、算法实现

public class DP_Knapsack01 {

int[] weight;
int[] value;
int max;

int[][] p;

boolean[] selection ; //背包是否被选择

public DP_Knapsack01() {
    weight = new int[] {0, 16, 15, 15 };
    value = new int[] {0, 45, 25, 25 };
    max = 30;
    selection = new boolean[weight.length];

    init();
}

private void init() {
    int row = weight.length;
    int col = max+1 ;
    int i, j;

    p = new int[row][col];
    //初始化第0列
    for(i=0;i<row;i++)
        p[i][0]=0;

    // 表示初始时刻没装入物品时，最大价值为0
    for(j=0;j<col;j++)
        p[0][j]=0;

}

/*
 * DP:选择与否的最优子结构性质
 * p[i][j]表示前i个物品能装入载重量为j的背包中的最大价值
 * p[i][j] = max{p[i-1][j],value[i]+p[i-1][j-weight[i]]}
 * */
/*
 * 该段程序完成以下n个阶段：
 1：只装入1个物品，确定在各种不同载重量的背包下，能够得到的最大价值
 2：装入2个物品，确定在各种不同载重量的背包下，能够得到的最大价值
   。。。
 n：以此类推，装入n个物品，确定在各种不同载重量的背包下，能够得到的最大价值
 * */
private void knapsack() {
    int i, j;
    for (i = 1; i < weight.length; i++) {
        for (j = 1; j < max+1; j++) {
            //weight[i]>j,第i个物品不装入背包
            p[i][j] = p[i - 1][j];
            //weight[i]<=j,且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值
            int temp;
            if(j >=weight[i])
            {
                temp = p[i - 1][j - weight[i]] + value[i];
                if (temp > p[i][j])
                    p[i][j] = temp;
            }
        }
    }
}

/* 求装入的物品
 * 递推从value[n][max]向前逆推。
 * 若p[n][max]>p[n-1][max]，则第n个物品被装入背包，且前n-1个物品
 * 被装入载重量为max-weight[n]的背包中。
    否则，第n个物品没有装入背包，且前n-1个物品被装入载重量为max的背包中。
 * */
private void traceback()
{
    int temp = max;
    int len = weight.length;
    for (int i = len-1; i >0; i--) {
        if(p[i-1][temp]<p[i][temp])
        {
            selection[i] = true;
            temp-=weight[i];
        }
    }
}

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub

    DP_Knapsack01 knap = new DP_Knapsack01();
    knap.knapsack();

    knap.traceback();
    int len = knap.weight.length;

    System.out.println("动态规划对应的value值分别为：");
    for(int i= 0;i<len;i++)
    {
        if(knap.selection[i])
            System.out.print(knap.value[i]+" ");
    }
    System.out.println();
    System.out.println("动态规划对应的weight值分别为：");
    for(int i= 0;i<len;i++)
    {
        if(knap.selection[i])
            System.out.print(knap.weight[i]+" ");
    }
}

}

参考资料：

http://blog.csdn.net/livelylittlefish/article/details/2186206