背包九讲一 01背包

https://www.acwing.com/problem/content/2/

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

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

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

数据范围
0<N,V≤1000

0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

解答
dp[x][y] 表示只从前x个物品选择放入背包，物品总体积和达到体积y的时候能达到的最大价值(第x物品可选择也可不选择)

那么就可以得出下面的代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010; //范围稍微扩大10个 防止无谓的边界问题
int dp[N][N]; //表示只从前x个物品选择放入背包，物品总体积和达到体积y的时候能达到的最大价值 
int n,v;
struct GOODS{
    int v,w;
}goods[N];

int main(){
    cin >> n>>v;
    //接收数据，  从1开始 方便后面dp避免一些边界问题
    for(int i= 1;i<=n;i++){cin >>goods[i].v>>goods[i].w;}
    
    
    //dp从1开始 避免一些边界问题
    for(int i =1;i<=n;i++){
        for(int j=0;j<=v;j++){
            dp[i][j]=dp[i-1][j];
            if(j>=goods[i].v){
                //遍历到j大于本轮货物的题解 才考虑减， 否则会出现负数索引
                dp[i][j]=max(dp[i][j],dp[i-1][j-goods[i].v]+goods[i].w);
            }
        }
    }
    
    cout << dp[n][v]<<endl;
}

题外话1 精确求第x个物品刚好达到体积y时候的最大价值
通过调试我们会发现dp[x][y] 表示只从前x个物品选择放入背包，物品总体积和达到体积y的时候能达到的最大价值
dp[x][y] dp[x][y+1] dp[x][y+2] 可能在体积y达到最大价值后，后面y+1，y+2也是这个最大价值
也就是说按照定义一个空包放入一个体积为3 价值为5的物品时， dp[1][3]=5 dp[1][4]=5 dp[1][5]=5 dp[1][6]=5
如果我们想精确求第x个物品刚好达到体积y时候的最大价值
就等于一个空包放入一个体积为3 价值为5的物品时， dp[1][3]=5 但是，后面的dp未必等于5 dp[1][4]！=5 dp[1][5]！=5 dp[1][6]1=5
想解决这个需求，那么我们在初始状态时候除了dp[0][0]=0 其他dp[0][x]均赋值为一个极小数即可。
此时do的意义就变化为，在于没有物品的时候体积0 的最大价值是0，其他状态是不存在所以赋值不可能存在意义的极小值。
就得到了精确求第x个物品刚好达到体积y时候的最大价值
这种思路下的解答我们最后就要遍历dp[n][x] ，得到某个体积的最大值才是正确的答案

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010; //范围稍微扩大10个 防止无谓的边界问题
int dp[N][N]; //第x个物品 达到体积y 时候能达到的最大价值
int n,v;
struct GOODS{
    int v,w;
}goods[N];

int main(){
    cin >> n>>v;
    //接收数据，  从1开始 方便后面dp避免一些边界问题
    for(int i= 1;i<=n;i++){cin >>goods[i].v>>goods[i].w;}
    
    for(int i=0;i<N;i++){
        for(int j = 0;j<N;j++){
            dp[i][j]=-999999999;//(INT_MIN)
        }
    }
    //没有物品的时候 体积0 的最大价值是0，其他状态不存在 所以赋值不可能存在意义的极小值。
    //这样递归就只能从精准的dp[0][0]开始转移  
    //比如放入体积为1 价值为2的物品dp[1][1] = dp[0][0]+2;
    //i=1 j=1  dp[i][j] = dp[i-1][j-1]+2; 
    dp[0][0]=0;  
    
    //dp从1开始 避免一些边界问题
    for(int i =1;i<=n;i++){
        for(int j=0;j<=v;j++){
            dp[i][j]=dp[i-1][j];
            if(j>=goods[i].v){
                //遍历到j大于本轮货物的题解 才考虑减， 否则会出现负数索引
                dp[i][j]=max(dp[i][j],dp[i-1][j-goods[i].v]+goods[i].w);
            }
        }
    }
   
    //cout << dp[n][v]<<endl;
    int ans =0;
    //我们最后就要遍历dp[n][x] ，得到某个体积的最大值 才是正确的答案
    for(int i =0;i<=v;i++){
        ans = max(dp[n][i],ans);
    }
    cout << ans<<endl;
}

题外话2 滚动数组
在第一段代码中我们注意到，每次dp转移只和上一次的dp[i-1][]有关，
那么其实我们只需要设置两组数组就可以了，可以大大减少dp数组的空间。

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010; //范围稍微扩大10个 防止无谓的边界问题
//int dp[N][N]; //表示只从前x个物品选择放入背包，物品总体积和达到体积y的时候能达到的最大价值 
int dp[2][N]; //表示只从前x个物品选择放入背包，物品总体积和达到体积y的时候能达到的最大价值 
int n,v;
struct GOODS{
    int v,w;
}goods[N];

int main(){
    cin >> n>>v;
    //接收数据，  从1开始 方便后面dp避免一些边界问题
    for(int i= 1;i<=n;i++){cin >>goods[i].v>>goods[i].w;}
    
    //我们可以只关心当前dp数组和之前的dp数组 两组数组即可
    int curr=0; int prev=1;
    //dp从1开始 避免一些边界问题
    for(int i =1;i<=n;i++){
        for(int j=0;j<=v;j++){
            //dp[i][j]=dp[i-1][j];
            dp[curr][j]=dp[prev][j];
            /*if(j>=goods[i].v){
                //遍历到j大于本轮货物的题解 才考虑减， 否则会出现负数索引
                dp[i][j]=max(dp[i][j],dp[i-1][j-goods[i].v]+goods[i].w);
            }*/
             if(j>=goods[i].v){
                //遍历到j大于本轮货物的题解 才考虑减， 否则会出现负数索引
                dp[curr][j]=max(dp[curr][j],dp[prev][j-goods[i].v]+goods[i].w);
            }
        }
        //翻转curr prev 当前的curr在下一循环就变成了prev
        swap(curr,prev);
    }
    //最后一组 由于翻转了curr prev才跳出循环 所以这里使用prev才是答案
    cout << dp[prev][v]<<endl;
}

题外话3 二维降一维

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010; //范围稍微扩大10个 防止无谓的边界问题
int dp[N]; 
int n,v;
struct GOODS{
    int v,w;
}goods[N];

int main(){
    cin >> n>>v;
    //接收数据，  从1开始 方便后面dp避免一些边界问题
    for(int i= 1;i<=n;i++){cin >>goods[i].v>>goods[i].w;}
    for(int i=1;i<=n;i++){
        for(int j= v;j>=0;j--){
            if(j >= goods[i].v)
                dp[j] = max(dp[j],dp[j-goods[i].v]+goods[i].w);
        }
    }
    
    cout << dp[v]<<endl;
}