背包问题

背包问题描述：

有一个小偷在偷窃一家商店时发现有 n 件物品，第 i 件物品价值 v_i 元，重 w_i 磅，此处 v_i 和 w_i 都是整数。小偷希望带走的物品价值越高越好，但他的背包至多只能装下 W 磅的东西，W 为整数。那么，小偷应该带走哪些物品呢？

背包问题可以包含不同的限定条件：

• 部分背包问题：可以带走物品的一部分，而不必做出 0-1 的二分选择。
• 0-1 背包问题：每件物品或者带走或者留下，不能只带走一部分或者带走两次以上。

部分背包问题拥有典型的贪心选择性质，可以使用贪心算法来解决。0-1 背包问题中需要考虑背包是否填满以取得最高的价值，在比较物品加进去或不加进去的子问题时产生了许多重叠的子问题，可以使用动态规划算法来解决。

部分背包问题

有一个小偷在偷窃一家商店时发现有 n 件物品，第 i 件物品价值 v_i 元，重 w_i 磅，此处 v_i 和 w_i 都是整数。小偷希望带走的物品价值越高越好，但他的背包至多只能装下 W 磅的东西，W 为整数。为尽可能多的带走更多的东西，小偷可以带走物品的一部分，而不必做出 0-1 的二分选择。那么，小偷应该带走哪些物品呢？

最优子结构

如果从最优物品组合中去掉某物品 j 的重量 w 磅，则余下的物品必须是可以从 n - 1 件物品和物品 j 余下的 w_j - w 磅中可带走的、重量至多为 W - w 的最值钱的一组东西。

贪心选择性质

每件物品计算每磅的价值 v_i / w_i，小偷开始从具有最大价值的物品尽量多取一些，如果拿完该物品后背包还有余量，则可继续取价值次大的物品，以此类推，直到背包取满为止。

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace AlgorithmTests
{
  class Program
  {
    static void Main(string[] args)
    {
      int n = 3;
      int[] values = new int[3] { 60, 100, 120 };
      int[] weights = new int[3] { 10, 20, 30 };
      int W = 50;
 
      GreedyKnapsack(n, values, weights, W);
 
      Console.ReadKey();
    }
 
    static void GreedyKnapsack(int n, int[] values, int[] weights, int W)
    {
      // 计算物品每磅价值
      Dictionary<int, double> valuePerPound = new Dictionary<int, double>();
      for (int i = 0; i < n; i++)
      {
        valuePerPound.Add(i, values[i] / weights[i]);
      }
 
      // 按照每磅价值从大到小排序
      int[] orderedPerPound = valuePerPound
        .OrderByDescending(v => v.Value)
        .Select(v => v.Key)
        .ToArray();
 
      // 计算装包量
      int filling = W;
      int totalValue = 0;
      int j = 0;
      List<int> packed = new List<int>();
      while (filling > 0)
      {
        if (filling >= weights[orderedPerPound[j]])
        {
          // 完全装入
          filling -= weights[orderedPerPound[j]];
          totalValue += values[orderedPerPound[j]];
          packed.Add(weights[orderedPerPound[j]]);
        }
        else
        {
          // 部分填装
          totalValue += filling * values[orderedPerPound[j]] / weights[orderedPerPound[j]];
          filling = 0;
          packed.Add(weights[orderedPerPound[j]]);
        }
 
        j++;
      }
 
      Console.WriteLine(totalValue);
      foreach (var item in packed)
      {
        Console.WriteLine(item);
      }
    }
  }
}

0-1 背包问题

有一个小偷在偷窃一家商店时发现有 n 件物品，第 i 件物品价值 v_i 元，重 w_i 磅，此处 v_i 和 w_i 都是整数。小偷希望带走的物品价值越高越好，但他的背包至多只能装下 W 磅的东西，W 为整数。每件物品或者带走或者留下，不能只带走一部分或者带走两次以上。那么，小偷应该带走哪些物品呢？

最优子结构

重量至多为 W 磅的价值最高的一组物品，如果从中去掉物品 j，余下的必须是小偷从除 j 以外的 n - 1 件物品中可以带走的重量至多为 W - w_j 的价值最高的一组物品。

重复子问题

当考虑是否要把一件物品加到背包中时，必须把该物品加进去的子问题的解与不加进去的子问题的解进行比较，也就产生了许多重叠的子问题。

状态

dp[i, j] 表示前 i 个物品装到剩余容量为 j 的背包里能达到的最大价值。

int[,] dp = new int[n + 1, W + 1];

状态转移方程

考查第 i 个物品装入背包的时候，其实是在考查第 i-1 个物品装不装入背包。

dp[i, j] = max{ dp[i-1, j], dp[i-1, j-weights[i-1]] + values[i-1] }

using System;
using System.Collections.Generic;
using System.Linq;

namespace AlgorithmTests
{
  class Program
  {
    static void Main(string[] args)
    {
      int n = 3;
      int[] values = new int[3] { 60, 100, 120 };
      int[] weights = new int[3] { 10, 20, 30 };
      int W = 50;

      DynamicProgrammingKnapsack(n, values, weights, W);

      Console.ReadKey();
    }

    static void DynamicProgrammingKnapsack(int n, int[] values, int[] weights, int W)
    {
      // 状态 dp[i, j] 表示前 i 个物品装到剩余容量为 j 的背包里能达到的最大价值
      int[,] dp = new int[n + 1, W + 1];

      // 状态转移方程
      // dp[i, j] = max{ dp[i-1, j], dp[i-1, j-weights[i-1]] + values[i-1] }
      // 考查第 i 个物品装入背包的时候，其实是在考查第 i-1 个物品装不装入背包
      for (int i = 0; i <= n; i++)
      {
        for (int j = 0; j <= W; j++)
        {
          if (i > 0 && j >= weights[i - 1])
          {
            int v = dp[i - 1, j - weights[i - 1]] + values[i - 1];
            if (v > dp[i - 1, j])
            {
              dp[i, j] = v;
            }
            else
            {
              dp[i, j] = dp[i - 1, j];
            }
          }
        }
      }

      Console.WriteLine(dp[n, W]);
    }
  }
}

本篇文章《背包问题》由 Dennis Gao 发表自博客园，未经作者本人同意禁止任何形式的转载，任何自动或人为的爬虫转载行为均为耍流氓。