背包问题汇总（背包九讲笔记）

背包问题是动态规划等算法的入门问题，这里列举一些常见类型

规定：$w$数组代表物品重量（成本），$val$数组代表物品价值，$n$代表物品数量，$V$代表背包体积

• 01背包（动态规划）：每个物品只能取一次（只有两种选择，取 $or$ 不取）

  复杂度为$O(n\ast V)$

  注意 ：建表时，每个位置由上一排相应（左上 $or$ 正上）位置决定，因此一维数组时，循环背包体积必须从右往左

  • 二维数组：

  cin >> n >> V;
  for(int i = 1; i <= n; i++) cin >> val[i] >> w[i];
  for(int i = 1; i <= n; i++)
  for(int j = V; j >= 0; j--){
  	if(j >= w[i]) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + val[i]);
  	else dp[i][j] = dp[i - 1][j];
  	}
  cout << dp[n][V] << endl;
  

  • 一维数组：

  cin >> n >> V;
  for(int i = 1; i <= n; i++) cin >> val[i] >> w[i];
  for(int i = 1; i <= n; i++)
  for(int j = V; j >= 0; j--){
  	if(j >= w[i]) dp[j] = max(dp[j], dp[j - w[i]] + val[i]);
  	else dp[j] = dp[j];
  }
  cout << dp[V] << endl;
  

• 超大01背包（回溯法）：每个物品只能取一次，但当物品数量$n$极小，此时物品质量$w$，价值$val$和背包体积$V$可能极大（$1e9+$）时，利用动态规划仍会超时

  最坏复杂度为$O(n\ast 2^n)$，最好复杂度（右节点大部分被剪枝）接近$O(n)$

  void dfs(int now, int wt, ll val){
      if(now == n + 1) ans = max(ans, val);
      if(val + sum[n] - sum[now - 1] > ans){  //剪枝:如果剩下的sum[n] - sum[now - 1]全都加上都不超过之前算的最优解ans,那么不要也罢！
          dfs(now + 1, wt, val);  //不选
          if(wt + w[now] <= V) dfs(now + 1, wt + w[now], val + v[now]);  //选
      }
  }
  int main(){
      cin >> n >> V;
      fora(i, 1, n){
          cin >> w[i] >> v[i];
          sum[i] = sum[i - 1] + v[i];  //sum表示前缀和
      }
      dfs(1, 0, 0);
      cout << ans << endl;
  }
  

• 完全背包（动态规划）：每件物品都可无限次重复购买
  复杂度约为$O(n\ast V)$

  • 二维数组

  for(int i = 1; i <= n; i++)
      for(int j = w[i]; j <= V; j++)  //循环顺序不同
          dp[j] = max(dp[i - 1][V], dp[i][j - w[i]] + val[i]);  //选择物品时，从第i行本行选(由于可多次选择)
  cout << dp[n][V] << endl;
  

  • 一维数组

  for(int i = 1; i <= n; i++)
      for(int j = w[i]; j <= V; j++)
          dp[j] = max(dp[V], dp[j - w[i]] + val[i]);
  cout << dp[V] << endl;
  

  • 可运用二进制方法减少复杂度（移步多重背包）：复杂度约为$O(V\ast \sum \log \frac{V}{w_i})$

• 多重背包（动态规划）：每件物品都可有限次（$cnt[i]$）重复购买，可运用二进制方法减少复杂度转为01背包
  复杂度约为$O(V\ast \sum \log cn{t}_i)$

  cin >> n >> sum;
  for(int i = 1; i <= n; i++) cin >> val[i] >> w[i] >> cnt[i];
  for(int i = 1; i <= n; i++){
      int k = 1;
      while(k <= cnt[i]){  //转为01背包
          for(int j = sum; j >= w[i] * k; j--) dp[j] = max(dp[j], dp[j - w[i] * k] + val[i] * k);
          cnt[i] -= k;
          k *= 2;  //采用二进制思想
      }
      for(int j = sum; j >= w[i] * cnt[i]; j--) dp[j] = max(dp[j], dp[j - w[i] * cnt[i]] + val[i] * cnt[i]);
  }
  cout << dp[sum] << endl;
  

  稍作改进：一部分化为完全背包，快了一点

  cin >> n >> sum;
  for(int i = 1; i <= n; i++) cin >> val[i] >> w[i] >> cnt[i];
  for(int i = 1; i <= n; i++){
      if(w[i] * cnt[i] >= sum)  //为完全背包问题
          for(int j = w[i]; j <= sum; j++) dp[j] = max(dp[j], dp[j - w[i]] + val[i]);
      else{  //为01背包问题
          int k = 1;
          while(k <= cnt[i]){
              for(int j = sum; j >= w[i] * k; j--) dp[j] = max(dp[j], dp[j - w[i] * k] + v[i] * k);
          	cnt[i] -= k;
          	k *= 2;  //采用二进制思想
          }
          for(int j = sum; j >= w[i] * cnt[i]; j--) dp[j] = max(dp[j], dp[j - w[i] * cnt[i]] + v[i] * cnt[i]); //二进制后剩余物品,依然用01背包视为一件
      }
  }
  cout << dp[sum] << endl;
  

• 部分背包（贪心算法）：每件物品都可拆分部分购买
  复杂度为$O(n)$

  struct AC{
      double v, w;
      double avg;
  }obj[1005];
  bool cmp(AC a, AC b){ return a.avg > b.avg;}
  int main(){
      cin >> V >> n;
      for(int i = 1; i <= n; i++){
          cin >> obj[i].v >> obj[i].w;
          obj[i].avg = obj[i].v / obj[i].w;
      }
      sort(obj + 1, obj + 1 + n, cmp);
      for(int i = 1; i <= n; i++){
          if(obj[i].w < V){
              ans += obj[i].v;
              V -= obj[i].w;
          }
          else{
              ans += obj[i].avg * V;
              break;
          }
      }
      cout << ans << endl;
  }