背包问题（01背包）

题目：46. 携带研究材料（第六期模拟笔试）

二维数组

创建二维数组

最小的形状是[n][bagweight+1]，即在物品维度上需要装得下所有物品，在重量维度上，要包括[0, bagweight]，因为是闭区间，所以要+1；

初始化

	重量 0	1	2	3	4
物品 0	0	15	15	15	15
1	0
2	0

简单来说，初始化二维数组就初始化第一行好啦，前提是二维数组其他地方都初始化为0；

状态转移方程：f[i][j] = max(f[i-1][j], f[i-1][j-weight[i]] + value[i]);

#include <bits/stdc++.h>
using namespace std;

int n, bagweight;// bagweight代表行李箱空间

void solve()
{
    int i, j;
    vector<int> weight(n, 0); // 存储每件物品所占空间
    vector<int> value(n, 0);  // 存储每件物品价值
    vector<vector<int>> f(n, vector<int>(bagweight+1, 0));
    for(i = 0; i < n; i++) 
    {
        cin >> weight[i];
    }
    for(j = 0; j < n; j++) 
    {
        cin >> value[j];
    }
    
    // 初始化 第一行
    for(j = weight[0]; j <= bagweight; j++)
    {
        f[0][j] = value[0];
    }
    
    for(i = 1; i < n; i++)
    {
        for(j = 1; j <= bagweight; j++)
        {
            // 放不了 i
            if(j < weight[i])
            {
                f[i][j] = f[i-1][j];
            }
            else
            {
                f[i][j] = max(f[i-1][j], f[i-1][j-weight[i]] + value[i]);
            }
        }
    }
    cout << f[n-1][bagweight];
    
}

int main() 
{
    while(cin >> n >> bagweight) 
    {
        solve();
    }
    return 0;
}

一维数组

是二维数组的空间优化版本，

创建一维数组

只有重量维度，最小的形状只需要[bagweight + 1]；

初始化

直接初始化为0；

转移方程

f[j] = max(f[j], f[j-costs[i]] + values[i]);
因为在二维数组版中，f[i], f[i-1]相当于当前状态和上一个状态，类似于x = x +1;中2个x的关系，所以可以改为一维数组形式；
注意下面遍历的时候，在遍历背包容量时，要从后往前遍历，这样才不会覆盖掉原来的数据；
（至于为什么会覆盖掉，可以试一下从前往后遍历试试）

我对一维数组的理解

因为f[i], f[i-1]相当于当前状态和上一个状态，这只考虑到价值这个变量，所以空间的考虑就不要来打扰，如果从前往后遍历空间，因为只有一维数组，所以会占用考虑了价值的结果，而如果从后往前遍历空间，就不会和考虑价值产生冲突；

// 一维dp数组实现
#include <iostream>
#include <vector>
using namespace std;

int main()
{
     // 读取 M 和 N
    int M, N, i, j;
    cin >> M >> N;

    vector<int> costs(M);
    vector<int> values(M);

    for (int i = 0; i < M; i++) 
    {
        cin >> costs[i];
    }
    for (int j = 0; j < M; j++) 
    {
        cin >> values[j];
    }
    // 读取数据完毕
    
    vector<int> f(N+1, 0);
    for(j = costs[0]; j <= N; j++)
    {
        f[j] = values[0];
    }
    
    for(i = 1; i < M; i++)
    {
        for(j = N; j >= 1; j--)
        {
            if(j < costs[i])
            {
                continue;
            }
            f[j] = max(f[j], f[j-costs[i]] + values[i]);
        }
    }
    cout << f[N];
    return 0;
}

参考

代码随想录，动态规划：01背包理论基础