动态规划——背包模型

1.01背包

题目含义：一共有n种商品（每种商品只有一个），背包体积为v，并且已知每种商品的体积和价值，求将商品放入背包的最大价值

状态表示：f[i][j] 为前i个物品放入背包，且总体积不超过j的最大价值

状态转移方程：f[i] = max( f[i-1][j] , f[i-1][j-v[i]] )（根据物品选 或 不选 分类）

普通版：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int V = 1e3 + 10;
int f[N][V];
int w[N] , v[N];
int main()
{
    int 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 = 0 ; j <= m;j++)
        {
            f[i][j] = f[i-1][j]; // 不选择第i个物品
            if( j >= v[i] ) // 确保 j >= v[i]
            f[i][j] = max(f[i][j] , f[i-1][j-v[i]] + w[i] );//选择第i个物品
        }
    }
    cout << f[n][m] << endl;
    return 0;
}

空间优化版：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int V = 1e3 + 10;
int f[V];
int w[N] , v[N];
int main()
{
    int 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--)// 从大到小
        {
            
           f[j] = max( f[j] , f[j-v[i]] + w[i] );
           
        }
    }
    cout << f[m] << endl;
    return 0;
}

2.完全背包

题目含义：一共有n种商品（每种商品有无数个），背包体积为v，并且已知每种商品的体积和价值，求将商品放入背包的最大价值

状态表示：f[i][j] 为前i个物品放入背包，且总体积不超过j的最大价值

状态转移方程：f[i] = max( f[i-1][j] , f[i][j-v[i]] + w[i] )（根据物品选 或 不选 分类）

分析状态转移方程：

1. 不选择第i个物品 f[i-1][j]

2. 选择第i个物品 （只选择一个 f[i-1][j-v[i]] + w[i] , 选择两个f[i-1][j-2*v[i]] + 2 * w[i] ...... 选择k个f[i-1][j-k*v[i]] + k*w[i] ）

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

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

二者结合-> f[i][j] = max(f[i-1][j] , f[i][j-v[i]] + w[i] )

普通版：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int V = 1e3 + 10;
int f[N][V];
int w[N],v[N];
int main()
{
    int 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 = 0 ; j <= m;j++)
        {
            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;
}

空间优化版：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int V = 1e3 + 10;
int f[V];
int w[N],v[N];
int main()
{
    int 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 = 0 ; j <= m;j++)// 只有完全背包 才是从小到大
        {
            
            if( j >= v[i] )f[j] = max(f[j] , f[j-v[i]] + w[i] );
        }
    }
    cout << f[m] << endl;
    return 0;
}

3. 多重背包

题目含义：一共有n种商品（每种商品有有限个），背包体积为v，并且已知每种商品的体积和价值，求将商品放入背包的最大价值

一般这种题往往需要优化 -> 优化方法为二进制优化

思路：将每种商品通过二进制的方法转换成01背包，在进行处理（原理任意一个数均可有 1 ，2 ，4,8,2^n等数字通过加法得到）

二进制优化版：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const int V = 1e4 + 10;
int v[N] , w[N];
int f[V];
int cnt;
int main()
{
    int n , m;
    cin >> n >> m;
    for(int i = 1;i <= n;i++)
    {
        int k = 1;
        int a , b , s;
        cin >> a >> b >> s;
        while( s >= k )
        {
            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;
}

4.二维费用的背包问题

题目含义：一共有n种商品，背包体积为v，背包承受的总重量为m ,并且已知每种商品的体积,价值和重量，求将商品放入背包的最大价值（就是限制条件增加1维）

思考方式与一维条件下的背包问题类似：

举一个具体的例子：

状态表示：f[i][j][k] 为前i个物品中选择，并且总体接不超过j，总重量不超过k的最大价值

状态转移方程：f[i][j][k] = max(f[i-1][j][k] , f[i-1][j-v[i]][k-m[i]] + w[] )

一般要空间优化，否则会MLE

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int M = 1e2 + 10;
const int V = 1e2 + 10;
int f[V][M];
int v[N] , w[N] , m[N] ;
int main()
{
    int n , a , b;
    cin>> n >> a >> b;
    for( int i = 1; i<= n;i++)
    {
        cin >> v[i] >> m[i] >> w[i];
    }
    for( int i = 1; i <= n;++i)
    {
        for(int j = a;j >= v[i] ; j--)
        {
            for( int k = b; k >= m[i] ;k--)
            {
                f[j][k] = max(f[j][k] , f[j-v[i]][k-m[i]] + w[i] );
            }
        }
    }
    cout << f[a][b] << endl;
    return 0;
}

5.分组背包问题

题目含义：

状态表示：前i组物品中选择，总体积不超过j的最大价值

状态转移方程：f[i][j] = max( f[i-1][j] , f[i-1][j-v[i][k]] + w[i][k] )

空间优化版：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;
int f[N];
int s[N] , v[N][N] , w[N][N];
int main()
{
    int n , m;
    cin >> n >> m;
    for( int i = 1 ;i<= n;i++)
    {
        cin >> s[i];
        for( int j= 1; j <= s[i] ;j++)
        {
            cin >> v[i][j] >> w[i][j];
        }
    }
    for( int i = 1; i <= n;i++)
    {
        for( int j = m ; j >= 0 ; j--)
        {
            for( int k = 1 ; k <= s[i] ; k++)
            {
                if( j >= v[i][k] )
                f[j] = max( f[j] , f[j-v[i][k]] + w[i][k] );
            }
        }
    }
    // 注意只能先枚举体积在枚举物品的个数
    // 如果先枚举物品的个数（本质是在组内进行01背包），首先枚举的物品更新的结果，可能会影响后面的结果
    // eg: 总体积 10 
    // 第一组内的物品 第一个 100 1  第二个 10 1
    //                f[1] = 100   -> f[2] = f[1] + 10 = 110
    //                违背组内只能选一个物品的规则
    // 因此只能先枚举物品的个数，在枚举体积
    cout << f[m];
    return 0;
}

6.背包问题求具体方案

题目含义：一共有n种商品（每种商品只有一个），背包体积为v，并且已知每种商品的体积和价值，求将商品放入背包的最大价值的选择方案

思路：已知最后的答案，倒推

由于求字典序最小 -> 最后要先从 1 枚举 -> 求最大价值时从 n - 1枚举物品

求具体方案时，不能进行空间优化

// 求字典序最小的版本
#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int f[N][N];
int w[N] , v[N];
int main()
{
    int n , m;
    cin >> n >> m;
    for( int i = 1; i <= n;i++)cin >> v[i] >> w[i];
    for(int i = n ; i >= 1;i--)
    {
        for( int j= 0 ; j<= m;j++)
        {
            f[i][j] = f[i+1][j];
            if( j >= v[i] )f[i][j] = max(f[i][j] , f[i+1][j-v[i]] + w[i] );
        }
    }
    int j = m;
    for( int i = 1; i <= n ; i++)
    {
        if( j >= v[i] && f[i][j] == f[i+1][j-v[i]] + w[i] )
        {
            cout << i << " "; j -= v[i];
        }
    }
    return 0;
}

// 一般的版本 -> 不求字典序最小
#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int f[N][N];
int w[N] , v[N];
int main()
{
    int 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= 0 ; j<= m;j++)
        {
            f[i][j] = f[i - 1][j];
            if( j >= v[i] )f[i][j] = max(f[i][j] , f[i - 1][j-v[i]] + w[i] );
        }
    }
    int j = m;
    for( int i = n; i >= 1 ; i--)
    {
        if( j >= v[i] && f[i][j] == f[i-1][j-v[i]] + w[i] )
        {
            cout << i << " "; j -= v[i];
        }
    }
    return 0;
}