1.01背包问题

 01背包问题是每件物品要么用0次，要么用1次，最多只用一次

dp[i][j]表示只从前i个物品中选，总体积<=j的选法的最大价值。

 

 二维做法

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N][N];
int v[N], w[N]; //v是每件物品的体积，w是每件物品的价值 
int main() {
    int n, m; //n是物品个数，m是背包容量 
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    //初始化dp[0][0~m]一件物品都没有选，所以是0 
    for (int i = 1; i <= n; i++) { //然后从第一件物品开始 
        for (int j = 0; j <= m; j++) { //枚举体积 
            //不含i的情况是一定存在的 
            dp[i][j] = dp[i - 1][j];
            //但是含i的情况是有条件的 
            if (j >= v[i]) { //只有能装下时才有这种情况 
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
            }
        }
    }
    /*for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }*/
    cout << dp[n][m] << endl;
    return 0;
}

输出中间变量

 然后我们将二维转化为一维

能转换为一维是由两个原因决定的

因为dp[i][]这一层只用到了dp[i - 1][]这一层，所以就可以运用滚动数组的思想

然后我们又发现了另外一个问题，关于j，我们用到的一个是j一个是j - v[i]，都是<= j的

所以我们就改为用一维数组来算

二维优化到一维，内层循环需要逆序

我们可以对比一下这两个式子:

dp[i][w]=max{dp[i-1][w],dp[i-1][w-wi]+vi}

 f[w]=max{f[w], f[w-wi]+vi}

可以发现, 在一维递归式里, 要求f[w-wi]+vi 这部分 代替 dp[i-1][w-wi]+vi这部分

我们现在又只有一维数组. 这就要保证, 在第i次外循环时, 调用的f[w-wi]实际上是基于第i-1次循环得到的值.

而逆序保证了, 对于f[w], 它要调用的f[w-wi]一定是第i层循环还没有更新过的, 换言之, f[w-wi]只有可能是第i-1层存储的数据.

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N];
int v[N], w[N]; //v是每件物品的体积，w是每件物品的价值 
int main() {
    int n, m; //n是物品个数，m是背包容量 
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    for (int i = 1; i <= n; i++) { //然后从第一件物品开始 
        for (int j = m; j >= v[i]; j--) { //枚举体积 
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
            //cout << "i: " << i << " j: " << j << " dp[j]: " << dp[j] << endl; 
            //dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
            //第i层算的dp[j]一定是dp[i][j], j - v[i]是严格小于j的
            //然后j是从小到大枚举的，所以说我们在算dp[j]的时候
            //dp[j - v[i]]在第i层已经被计算过了 
            
            //所以我们把体积从大到小枚举
            //这样的话，我们就保证了由于j - v[i] < j
            //所以我们在算dp[j]时，dp[j - v[i]]还没有被更新过 
            //那么它存的就是第i - 1层的j - v[i] 
        }
    }
    cout << dp[m] << endl;
    return 0;
}