背包算法

1、0-1背包问题：

   有 n 种物品和一个能承受最大重量为 c 的背包，物品 i 的重量为w[i]，价值为v[i]，求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。如果限定每种物品只能选择0个或1个，则问题称为0-1背包问题。

    解题思路：

   （1）构造一个m[n+1[c+1]的二位矩阵，m[i][j]表示在面对前 i 件物品时，且背包容量为 j 时能获取的最大价值。然后将该二维矩阵初始化为0.

   （2）当求前 i ( i从1到n进行迭代) 件物品放入容量为 j 的背包的最大价值时:

      如果第 i 件物品的重量比背包的容量 j 大，则不放第 i 件物品，此时问题转化为 “ 前 i-1 件物品放入容量为j的背包的最大价值 ”，表示为：

m[i][j] = m[i-1][j]        当  j < w[i]   

      如果第 i 件物品的重量比背包的容量 j 小，则第 i 件物品可以放进去，此时是选择放还是不放进去呢？如果放第 i 件物品，问题转化为 “ 前 i-1 件物品放入剩下的容量为 j-w[i] 的背包中获取的最大价值 ”，此时如果放进第 i 件物品后得到的价值（即：前 i-1 件物品放入剩下的容量为 j-w[i] 的背包中获取的最大价值 + 第 i 件物品的价值v[i]）比不放第 i 件物品得到的前 i 件（此时已经变为前 i-1件）物品放入容量为 j 的背包中的最大价值大，则放入第 i 件物品，否则就不放入第 i 件物品，表示为：

m[i][j]=max( m[i-1][j]，m[i-1][j-w[i]] + v[i] )    当 j <= w[i]    

  （3）实例：n = 6, c = 12, w[ ] = { 0,4,6,2,2,5,1 }, v[ ] = { 0,8,10,6,3,7,2 }。

    m[n+1][c+1]=0;           
    for (int i=1; i<n+1; i++)
    {
        for (int j =1; j<c+1; j++)
            {
                if ( j >= w[i] )
                    m[i][j] = max ( m[i-1][j]，m[i-1] [ j - w[i] ] + v[i] ) ;
                else
                    m[i][j] = m[i-1][j];
            }
    }
    value = m[n][c];

   如何知道该拿那些物品？

   另起一个数组x[]，x[i]=0表示没拿，x[i]=1表示拿了。m[n][c]为最优值，如果m[n][c] = m[n-1][c]，说明有没有第n件物品都一样，则x[n]=0；否则x[n]=1。当x[n]=0时，由m[n-1][c]继续构造最优解；当x[n]=1时，由m[n-1][c-w[i]]继续构造最优解。依此类推可以构造出所有最优解。

    int y = c;
    x[n+1]=0;
    for (int i = n; i>1; i--)
    {
        if ( m[i][y]==m[i-1][y] )
            x[i] = 0;
        else
        {
            x[i] = 1;
            y -= w[i];
        }
    }
    x[1] = ( m[1][y]>0 ) ? 1 : 0 ;

2、完全背包问题：

     完全背包问题描述：有 n 种物品和一个能承受最大重量为 c 的背包，物品 i 的重量为w[i]，价值为v[i]，求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。 

    完全背包问题与0-1背包问题的区别在于每一件物品的数量都有无限个，而0-1背包每件物品数量只有一个。

  （1）解题思路：

     由于本问题类似于0-1背包问题，在0-1背包问题中，物品要么取，要么不取，而在完全背包中，物品可以取0件、取1件、 取2件、...、取c/w[i]件为止。因此，可以直接在0-1背包的递推式中扩展得到，只需要在选取第i件物品时增加一个循环，迭代c/w[i]次，计算出选取多少件第i种物品时可以获得最大价值。

  1）初始化矩阵m[n+1][c+1]，m[i][j]表示前i件物品放入容量为j的容量中时的最大收益 ；

  2）选取第i件物品时的递推式：  

      f[i][j] = max（f[i - 1][j]，f[i-1][j - k* w[i]] + k*v[i]）   其中  1 <= k * w[i] <= c

  实例：n=6,c=12,w[]={0,4,6,2,2,5,1},v[]={0,8,10,6,3,7,2}。

    m[n+1][c+1]={0}
    for (int i = 1;i <= n;i++)  
    {  
        for (int j = 1;j <= c;j++)  
        {  
            m[i][j] = 0;                                             # 初始化为0            
            for (int k = 0;k*w[i] <= j;k++)              # 找出最大的f[i][j]
            {  
                m[i][j] = max（m[i][j]，m[i - 1] [j - k * w[i]] + k * v[i]）;  
            }  
        }  
    }  
    return m[n][c];  

   复杂度分析：程序需要求解n*c个状态，每一个状态需要的时间为O(c/w[i])，总的复杂度为O(n*c*Σ(c/w[i]))。

（2）算法优化：

    我们就通过一个三重循环实现了完全背包问题。由于k循环的最坏可能是从0循环到c，所以这个算法的时间复杂度为O(n*c*c)，然而，这样并不够好。 

    有心的朋友可以自己根据流程画张表看看，认真分析的话不难发现这个算法中有很多多余的计算。 在m[i][j]中选择k个情况，和在m[i][j-w[i]]中选择k-1个的情况是相同的。 那么我们注意一下m[i][j]与m[i][j-w[i]]的关系，可以发现在求m[i][j]的值时，只需要直接从m[i][j-w[i]]和m[i-1][j]两个地方取值，并找出较大的那个就行了。 这样在计算m[i][j]时就不需要用到k循环了，下面给出改进的算法。 

  for (int i = 1; i < n; i++)
    {
        for (int j = 1; j <= c; j++)
        {
            if (j < w[i])
                m[i][j] = m[i-1][j];
            else
                m[i][j] = max（m[i-1][j]，m[i][ j-w[i] ]+v[i]）;
        }
    }

  return m[n][c];  

  这样就将时间复杂度降低到了O(n*W)。

3、多重背包问题：

    多重背包问题描述：有 n 种物品和一个能承受最大重量为 c 的背包，物品 i 的重量为w[i]，价值为v[i]，个数为num[i],求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。 

    多重背包和0-1背包、完全背包的区别：多重背包中每个物品的个数都是给定的，可能不是一个，绝对不是无限个。解题思路：
    多重背包问题和完全背包问题很类似，只不过对于物品i，可以取0件、1件、...、min{num[i] , c/w[i]}件，因此只需要在完全背包问题的基础上做以下改进，迭代次数改为min{c/w[i] , num[i] }件即可。

  1）初始化矩阵m[n+1][c+1]，m[i][j]表示前i件物品放入容量为j的容量中时的最大收益 ；

  2）选取第i件物品时的递推式：  

      f[i][j] = max（f[i - 1][j]，f[i-1][j - k* w[i]] + k*v[i]） 其中  1 <= k <=min{c/w[i] , num[i]} 

  实例：n=6,c=12,w[]={0,4,6,2,2,5,1},v[]={0,8,10,6,3,7,2},num[]={0,4,3,2,3,1,4}

    m[n+1][c+1]={0}
    for (int i = 1;i <= n;i++)  
    {  
        for (int j = 1;j <= c;j++)  
        {             
            int count = min(num[i], c/w[i]);
            m[i][j] = m[i-1][j];
            for(int k = 1; k <= count; k++)
             {
                int temp = f[i-1][j-w[i]*k] + k*v[i];
                if(temp >= m[i][j])
                     m[i][j] = temp;
             }
        }  
    }  
    return m[n][c];  

   复杂度分析：程序需要求解n*c个状态，每一个状态需要的时间为O(Σnum[i])，总的复杂度为O(n*c*Σnum[i]))。