01背包和完全背包（背包价值最大和背包恰好装满的价值最大）

背包问题简介

背包问题是一个经典的优化问题，它可以描述如下：给定一个固定容量的背包，以及一组物品，每个物品都有自己的重量和价值。目标是找到一种方式能够使得装入背包的物品总重量不超过背包容量，同时使得物品的总价值最大。
背包问题一般分为两类：

1. 0-1背包问题：每个物品只能选择放入背包一次或者不放入背包。
2. 完全背包问题：每个物品可以选择放入背包多次或者不放入背包。

01背包模板

你有一个背包，最多能容纳的体积是V。
现在有n个物品，第i个物品的体积为 vi，价值为 wi。

求这个背包至多能装多大价值的物品？

#include <cstring>
#include <iostream>
using namespace std;
const int N = 1010;
int v[1010];
int w[1010];
int dp[1010][1010];
int main()
{
    int n, V;
    cin >> n >> V;
    for(int i = 1; i <= n; i++) cin >> v[i] >> w[i]; // 输入物品体积金和价值
    // dp[i][j] 表示第 i 个物品时, 背包体积为 j, 最大价值为 dp[i][j]
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j]; // 不选的情况
            if(j - v[i] >= 0) dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    cout << dp[n][V] << endl;
    return 0;
}

若背包恰好装满，求至多能装多大价值的物品？

#include <cstring>
#include <iostream>
using namespace std;
const int N = 1010;
int v[1010];
int w[1010];
int dp[1010][1010];
int main()
{
    int n, V;
    cin >> n >> V;
    for(int i = 1; i <= n; i++) cin >> v[i] >> w[i]; // 输入物品体积金和价值 
    memset(dp, 0, sizeof(dp));
    // dp[i][j] 表示第 i 个物品, 背包体积恰好为 j 时, 最大价值为 dp[i][j], 不存在此状态就为 -1
    for(int j = 1; j <= V; j++) dp[0][j] = -1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= V; j++)
        {
            dp[i][j] = dp[i -1][j];
            if(j - v[i] >= 0 && dp[i - 1][j - v[i]] != -1)
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    if(dp[n][V] != -1) cout << dp[n][V] << endl;
    else cout << 0 << endl;
    return 0;
}

滚动数组对空间复杂度做优化，时间复杂度常数级优化
优化方法：将dp 表直接改为 一维度，所有带 i 的全部删去，代码如下：
需要注意的是，优化后的 dp 表在体积部分是从后往前填的

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int n = 0, V = 0;
int v[N], w[N];
int dp[N];
int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; i++)
    {
        cin >> v[i] >> w[i]; // 输入体积及价值
    }
    // dp[i][j]表示装到第 i 个物品,体积不超过 j 时的最大价值
    for(int i = 1; i <= n; i++)
    {
        for(int j = V; j >= v[i]; j--) // 从后往前填
        {
            dp[j] = max(dp[j], w[i] + dp[j - v[i]]);
        }
    }
    cout << dp[V] << endl;
    memset(dp, 0, sizeof(dp));
    // dp[i][j] 表示装到第 i 个物品,体积为 j 时的最大价值
    for(int j = 1; j <= V; j++) dp[j] = -1; // -1 表示这种情况不存在
    for(int i = 1; i <= n; i++)
    {
        for(int j = V; j >= v[i]; j--)
        {
            if(dp[j - v[i]] != -1) //dp[i - 1][j - v[i]] 状态必须存在才能加
                dp[j] = max(dp[j], w[i] + dp[j - v[i]]);
        }
    }
    if(dp[V] != -1) cout << dp[V] << endl;
    else cout << 0 << endl;
    return 0;
}

完全背包模板

你有一个背包，最多能容纳的体积是V。
现在有n种物品，每种物品有任意多个，第i种物品的体积为vi 吗，价值为wi

求这个背包至多能装多大价值的物品？
面对第 i 个物品，你可以选择拿 一 个、两个 等等，每次取背包体积允许范围内价值最大的。

状态转移方程推导过程：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int v[1010];
int w[1010];
int dp[1010][1010];

int main()
{
    int n, V;
    cin >> n >> V;
    for(int i = 1; i <= n; i++)
    {
        cin >> v[i] >> w[i];
    }
    // dp[i][j] 表示装到第 i 个物品时, 体积不超过 j 时的最大价值
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j];
            if(j - v[i] >= 0) dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    }
    cout << dp[n][V] << endl;
    return 0;
}

若背包恰好装满，求至多能装多大价值的物品？

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int v[1010];
int w[1010];
int dp[1010][1010];

int main()
{
    int n, V;
    cin >> n >> V;
    for(int i = 1; i <= n; i++)
    {
        cin >> v[i] >> w[i];
    }
    // 这个 dp[i][j] 表示装到第 i 个物品时, 体积恰好等于 j 时的最大价值
    for(int j = 1; j <= V; j++) dp[0][j] = -1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j];
            if(j - v[i] >= 0 && dp[i][j - v[i]] != -1)
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    }
    if(dp[n][V] == -1) cout << 0 << endl;
    else cout << dp[n][V] << endl;
}

使用滚动数组对完全背包问题作时间复杂度优化：
与 01 背包不同的是，这个的体积 dp 是从前往后。

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, V;
int v[N];
int w[N];
int dp[N];
int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; i++)
    {
        cin >> v[i] >> w[i];
    }
    // dp[i][j] 表示装到第 i 个物品时, 体积不超过 j 时的最大价值
    for(int i = 1; i <= n; i++)
    {
        for(int j = v[i]; j <= V; j++)
        {
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << dp[V] << endl;
    memset(dp, 0, sizeof(dp));
    // 这个 dp[i][j] 表示装到第 i 个物品时, 体积恰好等于 j 时的最大价值
    for(int j = 1; j <= V; j++) dp[j] = -1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = v[i]; j <= V; j++)
        {
            if(dp[j - v[i]] != -1)
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    if(dp[V] == -1) cout << 0 << endl;
    else cout << dp[V] << endl;
}