01背包和完全背包以及多重背包（最容易理解，可以同时记住三个）(论全面还得是这样)

01背包：

一个物品只能选择一次

有 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分析法：

dp :1.状态表示：

         集合：求出从前i个物品中选择体积不超过j的集合

         属性：最大值，其实就是求出上面集合的最大值也就是f[i][j]  就是从前 i个物品中选体积不超过j的最大价值

      2.状态计算 ：

         可以将f[i][j] 划分为两个部分：

                1.左半边部分：当此时的v[i] 体积是大于j的时候，说明f[i][j] 不包含i这个物品

                        所以f[i][j]=f[i-1][j]

                2.右半边部分：此时的v[i] 是小于等于j 的：1.当背包可以放下  i  的时候那么就要从前i-1个体积重选出重量是j-v[i] 的最大价值 f[i-1][j-v[i]] 加上你放进去的w[i]这个价值

                                                                                     2.当不可以放下的时候 此时为空集为0

                那么取出最大值就是max(f[i-1][j-v[i]]+w[i],0)其实就是  f[i-1][j-v[i]]+w[i]

       3.最后取出左右边两边的最大值：

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

                

代码：

#include<iostream>

using namespace std;

const int N=1010;

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];
    //f[0][0]是0，f[i][0]也是0，从前i 个物品选体积不超过0的最大价值不就是啥也选不了麻，就是0

     //f[0] [i] 也是如此
    //其实这边可以不用初始化了，只要没有输入的值默认是0了
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++)
        {
            f[i][j]=f[i-1][j];
            if(v[i]<=j){
                f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
            }
        }
    }
    cout<<f[n][m];
    
    return 0;

}

优化思路：

首先我们可以尝试将二维转化为一维的数组节省空间的占用

 f[i] [j] =f[i-1] [j] 的时候：

去掉 f[i]这个一维其实是等价的，毕竟都相等了，而且在此时价值相等，那么即使是求前 i 还是求 前 i-1 都是一样的那么f[j] = f [j] 我们可以把这一步给直接省略掉了

 if (v[i] <=j)的时候 ：

f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]); 尝试一下把f[i] 以及f[i-1]去掉看看等不等价

因为f[i][j]=f[i-1] [j] 那么可以先把第一个最大值f[i-1][j]写成f[j] 剩下的就是f[i-1][j-v[i]]+w[i]，因为此时求的是前i-1的体积不超过j- v[i] 的最大值，

而优化到一维后，如果我们还是正序，则有f[较小体积]更新到f[较大体积]，则有可能本应该用第i-1轮的状态却用的是第i轮的状态。所以我们得倒序输出

将v[i] 小于j 直接放到 j 循环条件里面然后倒序输出即可实现优化

优化代码：

#include<iostream>

using namespace std;

const int N=1010;

int n,m;
int v[N],w[N];
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]);
        }
    }
    cout<<f[m];//这边其实就是前n个物品中选择提及不超过m的最大价值
    
    
    return 0;
}

完全背包： 

就是在01背包的基础上加上了一个限制条件，一个物品可以选择多次

如果想要已经掌握了01背包那么完全背包可以速记：

和01背包的唯一区别就是在第二层循环的时候将倒序输出改为正序输出即可：

代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=1010;
int n,m;
int v[N],w[N];
int f[N];//表示我们要求出的最大价值

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
    //然后这边其实就可以不用初始化了，当没有存入的值的话默认都是0
    for(int i=1;i<=n;i++)
    {
        for(int j=v[i];j<=m;j++)//这边的条件是和01背包反过来的
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

思路：

在01背包的基础上 其实就是多了选择次数这一个条件

从一开始的选择一次到可以选择多次

那么就多了一层选择次数的循环：

闫式dp分析法：和01背包不一样的在于状态计算的时候 将一个集合划分为k个小块

当次数为0的时候：

那其实就是没有选择i 这个物品 那么就从前i-1 个物品中选择价值不超过j的最大价值

f[i] [j] =f [i-1][j]

当次数为k的时候：

f[i] [j]=f[i-1][j- k*v]+k*w 从前i-1个物品中选择体积不超过 j-k*v 的最大价值 并且还要加上放入的k个物品i 的价值

那么f[i][j] =max(f[i-1][j],f[i-1][j-v]+w,f[i-1] [j-k*v]+k*w....)

        f[i][j-v] =max(f[i-1] [j-v], f[i-1] [j-k*v]+(k-1)*w)

其实上面的等同于下面的加上一个w

完全背包：f[i][j]=max(f[i-1][j],f[i][j-v]+w)

01背包：f[i][j]=max(f[i-1][j],f[i-1][j-v]+w)

由此可以看出两者不同

所以可以直接去掉f[i] 不需要倒序输出 直接正序输出即可

代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=1010;
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];
    //然后这边其实就可以不用初始化了，当没有存入的值的话默认都是0
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)//这边的条件是和01背包反过来的
        {
            f[i][j]=f[i-1][j];
            if(v[i]<=j)
            f[i][j]=max(f[i-1][j],f[i][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m];
    return 0;
}

 优化代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=1010;
int n,m;
int v[N],w[N];
int f[N];//表示我们要求出的最大价值

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
    //然后这边其实就可以不用初始化了，当没有存入的值的话默认都是0
    for(int i=1;i<=n;i++)
    {
        for(int j=v[i];j<=m;j++)//这边的条件是和01背包反过来的
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

多重背包：

思路：

其实多重背包和01背包是相似的，只是选择次数不一样

首先一般小的数据可以直接加一层次数循环直接暴力过掉，但是大数据的话会直接爆掉

所以我们可以利用二进制来优化枚举选择的次数

例如 200

1 2 4 8.....64 下一个128加上的话就会超过200       所以 剩下的一个就是 200-（1+2+....64）=73

然后更新一下选择k次过后的体积和价值

最后根据更新过后的次数来进行最大值的比较 ：最后这一步和01背包是一样的

代码：

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=11010,M=2010;//数据范围一定要正确

int n,m;
int v[N],w[N];
int f[M];

int main()
{
    cin>>n>>m;
    int a,b,s;
    int cnt=0;
    
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b>>s;
        int k=1;
        while(k<=s)
        {
            
            v[++cnt]=k*a;
            w[cnt]=k*b;
            s-=k;
            k*=2;
        }

               if(s>0){
            
            v[++cnt]=s*a;
            w[cnt]=s*b;
        }
    }
    n=cnt;
    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]);
        }
    }
    
    cout<<f[m]<<endl;
    
    
    return 0;
}

希望可以帮到你哦 ，如果喜欢的话记得关注转发哦~ 😘