01背包问题DP详解

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N,V≤10000
0<vi,wi≤10000

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

8

DP问题中，我们先用DP思维写出朴素的写法，再在朴素写法中等价变换，优化我们的代码；

朴素写法中，以样例数据，计算顺序为：

f[1][0] = 0 f[1][1] = 2 f[1][2] = 2 f[1][3] = 2...
f[2][1] = 2 f[2][2]=max(f[1][2],f[1][0]+4)=4;f[2][3]=(f[1][3],f[1][1]+4)=6...后面都一样=6
f[3][1] = 2 f[3][2] = 4 f[3][3]=max(f[2][3],f[2][0]+4)=6 f[3][4]=(f[2][4],f[2][1]+4)=6
f[3][5]=(f[2][5],f[2][2]+4)=8
f[4][1]=2 f[4][2]=4 f[4][3]=6 f[4][4]=(f[3][4],f[3][0]+5)=6
f[4][5]=(f[3][5],f[3][1]+5)=7; 

f[i][j]表示在前i个物品中，装下的物品体积之和 <= j时的最大价值；

对于遍历到的每个第i个物品，我们只能从拿或者不拿中选，所以只需要求出：

不拿时 f[i - 1][j] 与 拿时 f[i - 1][j - v[i]] + w[i] （因为要拿第i个物品，所以先把第i个物品去除掉，找出去除第i个物品所生背包容量的前i - 1个物品选出的最大值）的最大值即可

为什么优化成一维后要反着遍历？

 如果不反过来：
    for(int i = 1;i <= n;i ++ )
        for(int j = v[i];j <= m;j ++ )  

       《 如果 j = 0~v[i] - 1;那么f[j]的值就等于上一层i -1层的f[j]值，多遍历，赋值一遍没有意义；所以直接从i = v[i]开始》

        f[j] = max(f[j],f[j - v[i]] + w[i]);

《正着写的话,f[j-v[i]]的 j - v[i]严格小于j,所以这里f[j-v[i]]的值就等于本层，之前遍历过（因为从小到大遍历，所以之前肯定遍历过,因为j - v[i]也可能大v[i]）的本层的求出来的：
                                    f[i][j - v[i]] + w[i]，

而我们要的是上一层f[i-1][j-v[i]]+w[i]的值，所以如果从大到小遍历,那么本层更小的j - v[i]在本层还没被遍历过。所以还是上一层i-1层的值：

                                f[i - 1][j - v[i]] + w[i]，

才正确》

//f[1][0] = 0 f[1][1] = 2 f[1][2] = 2 f[1][3] = 2
// f[2][1] = 2 f[2][2]=max(f[1][2],f[1][0]+4)=4;f[2][3]=(f[1][3],f[1][1]+4)=6
//f[3][1] = 2 f[3][2] = 4 f[3][3]=max(f[2][3],f[2][0]+4)=6 f[3][4]=(f[2][4],f[2][1]+4)=6
//f[3][5]=(f[2][5],f[2][2]+4)=8
//f[4][1]=2 f[4][2]=4 f[4][3]=6 f[4][4]=(f[3][4],f[3][0]+5)=6
//f[4][5]=(f[3][5],f[3][1]+5)=7;
#include<bits/stdc++.h> 
using namespace std;
const int N = 1e4;
int n,m;
int v[N],w[N];
/*朴素写法
int f[N][N];
int main()
{
    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 = 0;j <= m;j ++ )
        {
            if(j >= v[i])
                f[i][j] = max(f[i - 1][j],f[i - 1][j - v[i]] + w[i]); 
            else
                f[i][j] = f[i - 1][j];
        }
    }
    cout << f[n][m] << endl;
    return 0;
}
*/
// 优化写法
int f[N];
int main()
{
    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 -- )
            f[j] = max(f[j],f[j - v[i]] + w[i]);
    /*  为什么要反过来？
    如果不反过来：
    for(int i = 1;i <= n;i ++ )
        for(int j = v[i];j <= m;j ++ )  如果 j = 0~v[i] - 1;那么f[j]的值就等于上一层i -1层的f[j]值，多
                                        遍历，赋值一遍没有意义；所以直接从i = v[i]开始
            f[j] = max(f[j],f[j - v[i]] + w[i]); 正着写的话,f[j-v[i]]的 j - v[i]严格小于j,所以这里f[j-v[i]]
                                    的值就等于本层，之前遍历过（因为从小到大遍历，所以之前肯定遍历过,因为
                                    j - v[i]也可能大于v[i]）的本层的求出来的：
                                    f[i][j - v[i]] + w[i]，而我们要的是上一层f[i-1][j-v[i]]+w[i]的值，所以
                                    如果从大到小遍历,那么本层更小的j - v[i]在本层还没被遍历过。所以还是上一层
                                    i-1层的值：f[i - 1][j - v[i]] + w[i]的值,才正确
    */
    cout << f[m];
    return 0;
}