动态规划--0-1背包问题

问题描述:

有一个背包，它的容量为C(Capacity)，现在有n种不同的物品，编号为0..n-1，其中每一件物品的重量为W(i)，价值为v(i)。问可以向这个背包中盛放那些物品，使得在不超过背包容量的基础上，物品的总价值最大

使用递归解决问题的时候，要首先知道递归要解决怎样的问题，也就是说定义状态。首先有两个变量n个物品，容量为C的背包，所以：
  F(n，C)考虑将n个物品放进容量为C的背包，使得价值最大。

状态转移方程：
    F(i,c) = F(i-1,c) 
           = v(i)+F(i-1 , c-w(i))

考虑将i个物品放在容量为C的背包中，有两种选择（要么放入背包中，要么不放入背包中）。
对于不放入背包的情况，那些就是将n-1个物品放在容量为C的背包。
对于放入背包的情况，就是第i个物品的价值加上 i-1个物品放在容量为 c-w(i)容量的背包中

所以背包问题的解法就是求两种情况的最大值：
    F(i，C) = max( F(i-1,c), v(i)+c-w(i) )

递归的解法：

class Solution {

    //用[0..index]的物品，填充容积为C的背包获得最大价值
    int bestValue(int[] w, int[] v, int index, int c){
      //物品遍历完（所有都能放下），物品放不下的时候
        if(index < 0 || c <= 0)
          return 0;

        //物品选择不放入背包，最大价值由除了这个物品外的其他物品来决定  
        int res = bestValue(w, v, index-1, c);
       //物品选择放入背包， 
        if(c >= w[index])         //首先要保证能放进去
            res = max{res, v[index]+beastValue[w, v, index-1, c-w[index]]};

        return res;
    }

     //C 表示背包总容量，v[]表示每个物品的价值，w[]表示每个物品的重量
    public int knapsack(int[] w, int[] v, int c ) {
        //物品的个数
        int n = w.size();
        return bestValue(w , v, n-1, c);    
    }
}

递归的过程中 index 和 c的组合 存在重叠子问题的问题，所有可以使用记忆化搜索或者动态规划来解决。

由于背包问题有两个约束条件，每一个状态中被两个变量所定义的，所以开辟一个二维数组作为记忆化空间。

class Solution {
private:
    vector<vector<int>> memo;

     //用[0..index]的物品，填充容积为C的背包获得最大价值
    int bestValue(vector<int> &w, vector<int> &v, int index, int c){
        if(index < 0 || c <= 0)
            return 0;

        if(memo[index][c] != -1)
            return memo[index][c];

        //物品选择不放入背包，最大价值由除了这个物品外的其他物品来决定  
        int res = bestValue(w, v, index-1, c);
       //物品选择放入背包， 
        if(c >= w[index])         //首先要保证能放进去
            res = max{res, v[index]+beastValue[w, v, index-1, c-w[index]]};
        memo[index][c] = res;
        return res; 
    }

public:
   int knapsack(vector<int> &w, vector<int> &v, int c){
       int n = w.size(); 
       memo = vector<vector<int>>(n, vector<c+1,-1>);
        return bestValue(w, v, n-1, c);    
   }
};

动态规划：从地向下解决问题

首先举个小例子，观察一下动态规划解决这类问题的步骤：

由图可知，有3个物品和容量为5的背包。

当只考虑0号物品的时候，无论背包的容量为多少，都只能0号物品，所以最大的价值都为 6

当考虑 0 和 1 号物品的时候，有两种方案（方还是不放），比如对于[1][3]位置，如果不放入，那么就取[0][3]的数值（意味着只放入1号物品）； 如果放入，最大价值等于max{} [0][3], value[1] + [0][3-2]},你会发现对应的还是状态转移方程。

空间复杂度：O(n*c)

时间复杂度：O(n*c)

class Solution {
public:
   int knapsack(vector<int> &w, vector<int> &v, int c){
     int n = w.size();
     if(n == 0)
         return 0;

     vector<vector<int>> memo(n, vector<int>(c+1,-1));

     //最小规模的情况，当只放入0号物品的时候
     for(int j=0; j<=c;j++)
        memo[0][j] = (j >= w[0] ? v[0] : 0);  //放不下的为0

     for(int i=1; i<n; i++){
        for(int j =0; j<=c;j++){
          memo[i][j] = memo[i-1][j];
          if(j >= w[i])
            memo[i][j] = max(memo[i][j], v[i]+memo[i-1][j-w[i]]);
        }
     }
     return memo[n-1][c]; 
   }
};

==背包问题的优化1：==

从上面的状态定义和状态转移方程可知，第 i 行元素只依赖与第 i-1 行元素。所以理论上，只需要保持两行元素就可以。

空间复杂度：O(2 * c) = O(c)

int knapsack(vector<int> &w, vector<int> &v, int c){
     int n = w.size();
     if(n == 0)
         return 0;

     vector<vector<int>> memo(2, vector<int>(c+1,-1));

     //最小规模的情况，当只放入0号物品的时候
     for(int j=0; j<=c;j++)
        memo[0][j] = (j >= w[0] ? v[0] : 0);  //放不下的为0

     for(int i=1; i<n; i++){
        for(int j =0; j<=c;j++){
          memo[i%2][j] = memo[(i-1)%2][j];   //这样在物理层面只需要 2 行的数组
          if(j >= w[i])
            memo[i%2][j] = max(memo[i][j], v[i%2]+memo[(i-1)%2][j-w[i]]);
        }
     }
     return memo[(n-1)%2][c]; 
   }

“`