背包问题系列（01背包、完全背包、多重背包）

背包问题是一个经典的动态规划问题，问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。根据给定物品的数量，背包问题又可分为：

1）每种物品只有一件，即01背包问题

2）每种物品不限数量，可选取任意数量，即完全背包问题

3）每种物品的数量已给定，不可超出该数量，即多重背包问题

背包问题的重点：

1）编写状态转移方程

2）空间优化

 本文参考https://zhuanlan.zhihu.com/p/93857890，使用C++代码完成了三种问题的代码及空间优化代码

#include <iostream>
#include <vector>
using namespace std;

int max(int a, int b)
{
    return a > b ? a : b;
}

int min(int a, int b)
{
    return a < b ? a : b;
}

// 01背包问题,n件物品，重量为v
int BagProblem_01(const vector<int> &weight, const vector<int> &value, int n, int v)
{
    // 前i件物品背包限重为j的情况下的最大值
    vector<vector<int>> dp(n, vector<int>(v + 1, 0));

    for (int i = 0; i <= v; i++)
    {
        if (i >= weight[0])
        {
            dp[0][i] = value[0];
        }
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j <= v; j++)
        {
            if (j < weight[i])
            {
                dp[i][j] = dp[i - 1][j];
            }
            else
            {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
            }
        }
    }

    return dp[n - 1][v];
}

// 01背包问题--优化空间
int BagProblem_01_optimize(const vector<int> &weight, const vector<int> &value, int n, int v)
{
    // 前i件物品背包限重为j的情况下的最大值
    vector<int> dp(v + 1, 0);

    for (int i = 0; i <= v; i++)
    {
        if (weight[0] > v)
        {
            dp[0] = value[0];
        }
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = v; j >= weight[i]; j--)    // dp[j]是由上一行<=j列推出，j需逆向枚举
        {
            dp[j] = max(dp[j], dp [j - weight[i]] + value[i]);
        }
    }

    return dp[v];
}

// 完全背包问题
int BagProblem_complete(const vector<int> &weight, const vector<int> &value, int n, int v)
{
    vector<vector<int>> dp(n, vector<int>(v + 1, 0));

    for (int j = 0; j <= v; j++)
    {
        dp[0][j] = j / weight[0] * value[0];
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = 0; j <= v; j++)
        {
            if (j < weight[i])
            {
                dp[i][j] = dp[i - 1][j];
            }
            else
            {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
            }
        }
    }

    return dp[n - 1][v];
}

// 完全背包问题——优化空间
int BagProblem_complete_optimize(const vector<int> &weight, const vector<int> &value, int n, int v)
{
    vector<int> dp(v + 1, 0);

    for (int j = 0; j <= v; j++)
    {
        dp[j] = j / weight[0] * value[0];
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = 0; j <= v; j++)    // dp[j]是由上一行j列和本行小于j列推出，因此需要正向枚举
        {
            if (j >= weight[i])
            {
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
    }

    return dp[v];
}

// 多重背包问题
int BagProblem_multi(const vector<int> &weight, const vector<int> &value, const vector<int> &nums, int n, int v)
{
    vector<vector<int>> dp(n, vector<int>(v + 1, 0));

    for (int j = 0; j <= v; j++)
    {
        int num = min(j / weight[0], nums[0]);
        dp[0][j] = num * value[0];
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = 0; j <= v; j++)
        {
            if (j < weight[i])
            {
                dp[i][j] = dp[i - 1][j];
            }
            else
            {
                int num = min(j / weight[i], nums[i]);
                for (int k = 0; k <= num; k++)
                {
                    dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - k * weight[i]] + k * value[i]);
                }
            }
        }
    }

    return dp[n - 1][v];
}

// 多重背包问题——优化空间
int BagProblem_multi_optimize(const vector<int> &weight, const vector<int> &value, const vector<int> &nums, int n, int v)
{
    vector<int> dp(v + 1, 0);

    for (int j = 0; j <= v; j++)
    {
        int num = min(j / weight[0], nums[0]);
        dp[j] = num * value[0];
    }

    for (int i = 1; i < n; i++)
    {
        for (int j = v; j >= 0; j--)    // dp[j]是由上一行<=j列推出，需要逆向枚举
        {
            int num = min(j / weight[i], nums[i]);
            for (int k = 0; k <= num; k++)
            {
                if (j < k * weight[i])
                    continue;
                dp[j] = max(dp[j], dp[j - k * weight[i]] + k * value[i]);
            }
        }
    }

    return dp[v];
}

int main()
{
    int v = 10;
    int n = 5;
    vector<int> weight{ 2, 2, 4, 6, 3 };
    vector<int> value { 1, 3, 3, 5, 6 };
    vector<int> nums  { 1, 2, 3, 4, 1 };

    cout << BagProblem_01(weight, value, n, v) << endl;
    cout << BagProblem_01_optimize(weight, value, n, v) << endl;

    cout << BagProblem_complete(weight, value, n, v) << endl;
    cout << BagProblem_complete_optimize(weight, value, n, v) << endl;

    cout << BagProblem_multi(weight, value, nums, n, v) << endl;
    cout << BagProblem_multi_optimize (weight, value, nums, n, v) << endl;

    return 0;
}