第五章动态规划（一）（背包问题、）

一只程序媛li

已于 2024-04-08 14:11:34 修改

阅读量707

点赞数 23

分类专栏：蓝桥准备文章标签：动态规划算法

于 2024-02-25 20:57:08 首次发布

本文链接：https://blog.csdn.net/qq_61369552/article/details/136275616

版权

蓝桥准备专栏收录该内容

19 篇文章 2 订阅

订阅专栏

一、问题类型（状态的表示和状态的转移）

背包问题、线性dp、区间dp、状态压缩dp、树形dp、计数、数位统计、状态压缩、记忆化搜索。

二、背包问题

（一）0 1背包（每件物品最多只用一次）

N个物品，V个背包。每个物品v表示体积，w表示权重。背包能装下的情况下，求最大的总价值。

0.1背包dp的思考方式：

1、如何表示状态、如何计算：

如何表示状态：

2、状态就是一个满足条件的集合，集合是所有选法的集合（选哪些物品）。条件：只从前i个中选，总体积小于等于j。

3、状态的值f(i,j)就是集合的属性（max，min，数量）

4、答案是f(n,v)；

如何进行状态计算：

1、状态计算是对集合的划分，对集合划分子集，以及如何经过划分后的子集进行计算得到结果

2、对集合f(i,j)进行划分：划分的依据就是子集是否包含i。一个是不包含i，一个是必须包含i

3、如何对划分的子集进行计算得到最后的结果：

4、对于必须含i的子集。如果要求最大值，可以先不去考虑i号，因为必须要选i号，所以先把i号物品刨除去，计算f(i-1,j-vi)+wi。

5、max(f(i-1 , j), f(i-1,j-vi)+wi)

01背包二维写法

#include<bits/stdc++.h>
using namespace std;
// 2  01背包 二维写法
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=0;i<=m;i++)f[0][i]=0;

    //循环的方式扩大集合依次求解
    for(int i=1;i<=n;i++)
        for(int j=0;j<=m;j++)
        {
            //注意这样存在的一个错误性：vi比背包还大
            //f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
            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]<<endl;
    return 0;
}

转化为一维：

#include<bits/stdc++.h>
using namespace std;
// 2  01背包 一维写法
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=0;i<=m;i++)f[i]=0;

    //循环的方式扩大集合依次求解
    for(int i=1;i<=n;i++)
        //为什么从vi开始，因为小于vi的j保留上一层n-1的值就好了
        for(int j=m;j>=v[i];j--)
        {
            //因为在max里面的第二项是i-1时候的f值，
            //因为外层循环是i，每层循环都更新一次f[j]。
            //所以在下一层还未更新的时候保存的就是i-1层的值。

            if(v[i]<=j)f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    cout<<f[m]<<endl;
    return 0;
}

（二）完全背包（每件物品有无限个）

1、和01背包的区别是对集合的划分的时候是根据i号选了几个进行划分。

2、在计算后面1~k个子集的时候，与01背包类似：

而且可以k=0的时候公式也恰好适用。

3、状态转移方程为：

#include<bits/stdc++.h>
using namespace std;
// 3 完全背包二维写法
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=0;i<=m;i++)f[0][i]=0;

     //遍历所有集合的i的条件
    for(int i=1;i<=n;i++)
    {
        //遍历所有集合的j条件
        for(int j=0;j<=m;j++)
        {
            //遍历当前ij集合的所有可能子集进行状态计算
            for(int k=0;;k++)
            {
                if(v[i]*k>j)break;
                else f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
            }
        }

    }
    cout<<f[n][m]<<endl;
    return 0;
}

4、一样的思路使用循环数组每次保留i-1状态时的结果，如果装入后价值变大就更新，实现一维的转化。

#include<bits/stdc++.h>
using namespace std;
// 3 完全背包一维写法
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=0;i<=m;i++)f[i]=0;

     //遍历所有集合的i的条件
    for(int i=1;i<=n;i++)
    {
        //遍历所有集合的j条件
        for(int j=v[i];j<=m;j++)
        {
            //遍历当前ij集合的所有可能子集进行状态计算
         
            for(int k=0;;k++)
            {
                if(v[i]*k>j)break;
                //因为用到的都是当前i层的东西，需要和比j小的状态比较进行/更新所以内层循环只需要从小到大即可。
//01背包用的是i-1层的东西，从大到小更新
                else f[j]=max(f[j],f[j-v[i]*k]+w[i]*k);
            }
        }

    }
    cout<<f[m]<<endl;
    return 0;
}

5、观察发现每次循环遍历k的不必要的，枚举的k+1个式子的最大值就是f[i][j-v]+w.

如此就得到一个和01背包相似的一个状态转移方程，三重循环变成两层。

#include<bits/stdc++.h>
using namespace std;
// 3 完全背包一维写法
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=0;i<=m;i++)f[0][i]=0;

     //遍历所有集合的i的条件
    for(int i=1;i<=n;i++)
    {
        //遍历所有集合的j条件
        for(int j=0;j<=m;j++)
        {
            //注意和01背包一样后一项有条件的
          // f[i][j]=max(f[i-1][j],f[i][j-v[i]]+w[i]);
          f[i][j]=f[i-1][j];
          if(j>=v[i])f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        }

    }
    cout<<f[n][m]<<endl;
    return 0;
}

6、将其转化为一维

#include<bits/stdc++.h>
using namespace std;
// 3 完全背包一维写法
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=0;i<=m;i++)f[i]=0;

     //遍历所有集合的i的条件
    for(int i=1;i<=n;i++)
    {
        //遍历所有集合的j条件
        for(int j=v[i];j<=m;j++)
        {
          f[j]=max(f[j],f[j-v[i]]+w[i]);
        }

    }
    cout<<f[m]<<endl;
    return 0;
}

（三）多重背包（告诉每个物品具体有多少个）

1、多重背包相对于完全背包就是对k多了一个个数的限制

#include<bits/stdc++.h>
using namespace std;
// 4 多重背包i 二维写法
const int N=1010;
int n,m;
int v[N],w[N],s[N];
int f[N][N];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i]>>s[i];
    //全不选的话价值就是0
    for(int i=0;i<=m;i++)f[0][i]=0;

     //遍历所有集合的i的条件
    for(int i=1;i<=n;i++)
    {
        //遍历所有集合的j条件
        for(int j=0;j<=m;j++)
        {
           for(int k=0;k*v[i]<=j&&k<=s[i];k++)
           {
               f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
           }
        }

    }
    cout<<f[n][m]<<endl;
    return 0;
}

2、优化：把一个物品分解成多个物品，这多个物品按照01背包的方式组合得到这个物品选择数量的全部组合方式。

1023可以由 0,1,2,4,8…… 512 组合得到，由 n -> logn

例如对于si=200 如果再写128 就得到255了，而255是不可能的，64就终止，此时可凑出127 ，要得到200，还差73。

相当于用2进制表示数，而且二进制表示的数是连续的。最后凑的那个数相当于可用这个数加一个任意的二进制数达到si。

转化为了01背包每个数只能选一次。

#include<bits/stdc++.h>
using namespace std;
// 4 多重背包ii 二进制优化版本
const int N=25000;
int n,m;
int v[N],w[N],s[N];
int f[N];
int main()
{
    cin>>n>>m;
    int cnt=0;
    while(n--)
    {
        int a,b,S;
        cin>>a>>b>>S;
        int k=1;
        while(k<S)
        {
            S-=k;
            cnt++;
            s[cnt]=k;
            v[cnt]=a*k;
            w[cnt]=b*k;
            k*=2;
        }
        if(S)
        {
            cnt++;
            s[cnt]=S;
            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];
}

（四）分组背包每组里面只能选一个

在对集合进行划分的时候，完全背包是按照每种装几个，分组背包是按照每组装哪个

#include<bits/stdc++.h>
using namespace std;
// 9分组背包
const int N=110;
int n,m;
int v[N][N],w[N][N];
int s[N];//每组个数
int f[N][N];
int main()
{
   cin>>n>>m;
  for(int i=1;i<=n;i++)
   {
       cin>>s[i];
       for(int j=0;j<s[i];j++)
       {
           cin>>v[i][j]>>w[i][j];
       }
   }
   for(int i=1;i<=n;i++)
   {
       for(int j=0;j<=m;j++)
       {
           f[i][j]=f[i-1][j];//先将其初始化为上一层结果
           for(int k=0;k<s[i];k++)
           {
             //第一项是fij，因为一直要更新最大值。
             if(v[i][k]<=j)f[i][j]=max(f[i][j],f[i-1][j-v[i][k]]+w[i][k]);
           }
       }

   }
   cout<<f[n][m]<<endl;
   return 0;
}