01背包问题

01背包问题：给定n种物品和一背包。物品i的重量是wi其价值为vi，背包的容量为c。问如何选择装入背包的物品，使得装入背包中物品的总价值最大？

在选择装入背包的物品时，对每种物品i只有两种选择，即装入或者不装入。不能将物品i装入背包多次也不能只装部分的物品i。因此成为01背包问题。

01背包问题的经典解法是动态规划法。

动态规划的基本思想（出处）：

将一个问题分解为子问题递归求解，且将中间结果保存以避免重复计算。通常用来求最优解，且最优解的局部也是最优的。求解过程产生多个决策序列，下一步总是依赖上一步的结果，自底向上的求解。

动态规划算法可分解成从先到后的4个步骤：

1. 描述一个最优解的结构，寻找子问题，对问题进行划分。

2. 定义状态。往往将和子问题相关的各个变量的一组取值定义为一个状态。某个状态的值就是这个子问题的解（若有k个变量，一般用K维的数组存储各个状态下的解，并可根    据这个数组记录打印求解过程。）。

3. 找出状态转移方程。一般是从一个状态到另一个状态时变量值改变。

4.以“自底向上”的方式计算最优解的值。

5. 从已计算的信息中构建出最优解的路径。(最优解是问题达到最优值的一组解)

其中步骤1~4是动态规划求解问题的基础，如果题目只要求最优解的值，则步骤5可以省略。

设01背包问题的子问题的最优值为m(i,j)，m(i,j)是背包容量为j，可选物品为1，2，，，i时01背包问题的最优值。由01背包的性质可以得到状态转移方程：

m[i][j] = max(m[i-1][j],m[i-1][j-w[i-1]]+v[i-1]) (j>=wi)

m[i][j] = m[i-1][j] (0<=j<wi)

实现代码：

package _01pakage;

import java.util.Arrays;

/**
 *01背包问题
 *@author wxisme
 *@time 2015-10-20 下午5:37:17
 */
public class Solve_01pakage {
    

    /**
     * 
     * @param c 背包容量
     * @param n 物品种类
     * @param w 物品重量
     * @param v 物品价值
     * @return m[i][j] 将前i件物品装入背包可以获得的最大价值
     */
    public static int[][] knapSack(int c, int n, int[] w, int[] v) {
        
        int[][] m = new int[n+1][c+1];
        
        for(int i=0; i<=n; i++) {
            m[i][0] = 0;
        }
        
        for(int i=0; i<c+1; i++) {
            m[0][i] = 0;
        }
        
        for(int i=1; i<n+1; i++) {
            for(int j=1; j<c+1; j++) {
                //当第i件物品的重量小于当前背包容量时，可以放入可以不放入。
                if(w[i-1] <= j) {
                    boolean flag = m[i-1][j]<(m[i-1][j-w[i-1]]+v[i-1])?true:false;
                    //放
                    if(flag) {
                        m[i][j] = m[i-1][j-w[i-1]]+v[i-1];
                    }
                    //不放
                    else{
                        m[i][j] = m[i-1][j];
                    }
                    
                    /*
                     * 可以直接写成：
                      m[i][j] = Math.max(m[i-1][j], m[i-1][j-w[i-1]]+v[i-1]);
                    */
                    
                }
                else {
                    m[i][j] = m[i-1][j];
                }
                System.out.print(m[i][j] + " ");
            }
            System.out.println();
        }
        
        
        return m;
    }
    
    /**
     * 
     * @param m
     * @param n
     * @param w
     * @param c
     * @return
     */
    public static int[] traceBack(int[][] m, int n, int[] w, int c) {
        int[] ret = new int[n];
        
        Arrays.fill(ret, 0);
        
        //反推
        for(int i=n; i>0; i--) {
            //全局最优值
            if(m[i][c] > m[i-1][c]) {
                ret[i-1] = 1;
                c -= w[i-1];
            }
        }
        
        System.out.println("res:");
        for(int i=0; i<n; i++) {
            System.out.print(ret[i] + " ");
        }
        
        
        return ret;
    }

}

测试代码：

public static void main(String[] args) {
        int[] w = {2,2,6,5,4};
        int[] v = {6,3,5,4,6};
        int n = 5;
        int c = 10;
        
        traceBack(knapSack(c,n,w,v), n, w, c);
}

测试结果：

res:
1 1 0 0 1

可以跟踪一下m[][]的值

0 6 6 6 6 6 6 6 6 6
0 6 6 9 9 9 9 9 9 9
0 6 6 9 9 9 9 11 11 14
0 6 6 9 9 9 10 11 13 14
0 6 6 9 9 12 12 15 15 15