动态规划——背包问题优化

策z

已于 2024-05-14 21:14:31 修改

阅读量744

点赞数 15

分类专栏：动态规划文章标签：算法

于 2024-05-09 15:44:41 首次发布

本文链接：https://blog.csdn.net/victor_hq/article/details/129343864

版权

动态规划专栏收录该内容

4 篇文章 0 订阅

订阅专栏

背包问题

总结

一般f[i][j]表示的是前i个物品中，总体积不超过(恰好)j的所有方案的最大价值。
一般n表示物品种类数，m表示背包容量，v表示物品体积volume，w表示物品价值worth，s表示物品个数。
背包问题核心：物品数，体积，决策（状态转移的过程）。

01背包前k优解

题目传送门
在这里插入图片描述
本题没有啥思路，看了题解感觉很妙。对于想题目，可以扩展延伸再加一维，可能思路就会打开。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int f[N][60],t[N];


int main(){
	int k,m,n;
	cin>>k>>m>>n;
	memset(f,-0x3f,sizeof f);//敲黑板，因为是满包问题 
	f[0][1]=0;
	for(int i=1;i<=n;i++){
		int v,w;
		cin>>v>>w;
		for(int j=m;j>=v;j--){
			int c1=1,c2=1,len=1;
			while(c1+c2<=k+1){
				if(f[j][c1]>f[j-v][c2]+w)
					t[len++]=f[j][c1++];
				else
					t[len++]=f[j-v][c2++]+w;	
			}
			for(int z=1;z<=k;z++) f[j][z]=t[z];
		}
	}
	int ans=0;
	for(int i=1;i<=k;i++) ans+=f[m][i];
	cout<<ans<<endl;
	return 0;
}

多重背包

多重背包朴素版

//多重背包朴素版（庆功会） 
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=1000;
int n,m,f[N];

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		int v,w,s;
		cin>>v>>w>>s;
		for(int j=m;j>=0;j--)
		{
			for(int k=0;k<=s&&k*v<=j;k++)
				f[j]=max(f[j],f[j-k*v]+k*w);	
		} 
	}
	cout<<f[m]<<endl;
	return 0;
}

j>=0是因为由前i个物品一个都不选的情况。

多重背包二进制优化

#include<iostream>
using namespace std;
const int N=2020;
int f[N];
int V[N],W[N],cnt;

int main(){
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++){
        int v,w,s;
        cin>>v>>w>>s;
        int k=1;
        for(int k=1;k<=s;k=k*2){
            V[cnt]=k*v;
            W[cnt]=k*w;
            s-=k;
            cnt++;
        }
        if(s){
            V[cnt]=s*v;
            W[cnt]=s*w;
            cnt++;
        }
    }
    n=cnt;
    for(int i=0;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;
const int N=2100;
int f[N];

int main(){
	int n,m,v,w,s;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>v>>w>>s;
		for(int k=1;k<=s;s-=k,k*=2){
			for(int j=m;j>=k*v;j--){
				f[j]=max(f[j],f[j-k*v]+k*w);
			}
		}
		if(s){
			for(int j=m;j>=s*v;j--){
				f[j]=max(f[j],f[j-s*v]+s*w);
			}
		}
	}
	cout<<f[m]<<endl;
	return 0;
}

多重背包队列优化

多重背包队列优化是根据物品的体积来优化的。一维表示的话，从小到大遍历背包容量则需要备份上一层的数组，即每层需要备份一下上层数组。不同体积余数需要重新初始化单调队列，然后根据体积余数相同的进行分类更新f数组。这个单调队列里面，队头在左边，且q[hh]是队列里面价值最大的f下标,更新q队列把价值小的队尾踢出去，加入刚更新的背包容量，即更新的f下标。

//多重背包单调队列优化 
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=1000;
int n,m,f[N],g[N],q[N];//n表示种类 m表示背包容量 g数组表示上一层 
//q数组表示背包容量，hh，tt表示队列下标，数组内表示背包容量，即f数组下标
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		int v,w,s;
		cin>>v>>w>>s;
		memcpy(g,f,sizeof f);
		for(int j=0;j<v;j++){
			int hh=0,tt=-1;
			for(int k=j;k<=m;k+=v)
			{
				if(hh<=tt&&q[hh]<(k-s*v)) hh++;
				if(hh<=tt) f[k]=max(g[k],g[q[hh]]+(k-q[hh])/v*w);
				while(hh<=tt&&g[k]>=g[q[tt]]+(k-q[tt])/v*w) tt--;
				q[++tt]=k;
			}
		}
		
	}
	cout<<f[m];
	return 0;
}

混合背包

01背包是特殊的多重背包。多重背包二进制优化，是根据物品数量进行优化的一种方法，任何一个数都可以由二进制表示，所选物品数量的二进制表示数中，其中有多少个1就有多少个01背包种类被选。特别注意最后剩余物品数量，若不为零，还需要进行一次容量循环（最后一层）。

//混合背包 
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=1000;
int n,m,f[N];

int main(){
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		int v,w,s;
		cin>>v>>w>>s;
		if(s==0)
		{
			for(int j=v;j<=m;j++)
			{
				f[j]=max(f[j],f[j-v]+w);
			}
		}
		else
		{
			if(s==-1) s=1;
			for(int k=1;k<=s;k*=2)
			{
				for(int j=m;j>=k*v;j--)
				{
					f[j]=max(f[j],f[j-k*v]+k*w);
				}
				s-=k;
			}
			if(s)
			{
				for(int j=m;j>=s*v;j--)
					f[j]=max(f[j],f[j-s*v]+s*w);
			}
		}
	}
	cout<<f[m];
	return 0;
}

二维背包问题

费用背包问题

可推广到n维背包
潜水员是有限制的二维背包问题，因为其“体积1”，“体积2”

//二维费用背包问题
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=1000;
int n,m,f[N][N],m1;

int main(){
	scanf("%d%d%d",&n,&m,&m1);//物品种类数量，背包容量，背包最大重量 
	for(int i=0;i<n;i++)
	{
		int v,v1,w;
		cin>>v>>v1>>w;//物品体积，物品重量，物品价值 
		for(int j=m;j>=v;j--)
		{
			for(int k=m1;k>=v1;k--)
			{
				f[j][k]=max(f[j][k],f[j-v][k-v1]+w); 
			}	
		} 
	}
	cout<<f[m][m1]<<endl;
	return 0;
}

潜水员

//潜水员 
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=22,M=80;
int n,m,f[N][M],m1;

int main(){
	cin>>m>>m1>>n;
	memset(f,0x3f,sizeof f);
	f[0][0]=0;
	while(n--){
		int v,v1,w;
		cin>>v>>v1>>w;
		for(int j=m;j>=0;j--)
		{
			for(int k=m1;k>=0;k--)
			{
				f[j][k]=min(f[j][k],f[max(0,j-v)][max(0,k-v1)]+w);
			}
		}
	}
	cout<<f[m][m1]<<endl;
	return 0;
}

总结：对于到第i层，前i层所选体积j将由背包总体积数m遍历到0，但是当选第i个物品时，前面i-1个物品所选的总体积数为j-v，不为负数，即其要大于等于0，因此j>=v; 对于潜水员这题来说则没有这个容量限制，但是前i-1层总氧氮事实客观上是非负的。

分组背包问题（机器分配）

//机器分配 
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=22,M=80;
int n,m,f[N][M],w[N][M],way[N];

int main(){
	cin>>n>>m;//种类，体积  每一台表示体积1 
	 
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cin>>w[i][j];
	
	for(int i=1;i<=n;i++)
		for(int j=0;j<=m;j++)
			for(int k=0;k<=j;k++)//分组的本质是互斥的情况。选0,1,2...的情况 
				f[i][j]=max(f[i][j],f[i-1][j-k]+w[i][k]);
	cout<<f[n][m]<<endl;
	//求路径
	int j=m;
	for(int i=n;i;i--)
		for(int k=0;k<=j;k++)
			if(f[i][j]==f[i-1][j-k]+w[i][k])
			{
				way[i]=k;
				j-=k;
				break;
			}
	for(int i=1;i<=n;i++) cout<<i<<" "<<way[i]<<endl;
	return 0;
}

有依赖的背包问题

//有依赖的背包问题
//f[u][j]是以u为树根的子树里，包含树根的所有方案中，总体积不超过j的那些方案的最大价值 
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=110;
int n,m,f[N][N];
int v[N],w[N];//各体积，价值 
int h[N],e[N],ne[N],idx;//邻接表 

void add(int a,int b)//a指向b (a →b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u)
{
	for(int i=h[u];~i;i=ne[i])// 循环物品组; ~i表示不等于-1; h等同于ne，u等同于e 
	{
		int son=e[i];
		dfs(e[i]);
		//分组背包 
		for(int j=m-v[u];j>=0;j--)//循环体积 
			for(int k=0;k<=j;k++)//循环决策情况 
				f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]); 
	}
	//将物品u加进去 
	for(int i=m;i>=v[u];i--) f[u][i]=f[u][i-v[u]]+w[u];
	for(int i=0;i<v[u];i++) f[u][i]=0;
}
int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	int root;
	for(int i=1;i<=n;i++)
	{
		int p;
		cin>>v[i]>>w[i]>>p;
		if(p==-1) root=i;
		else add(p,i);//树是从根节点指下来到叶节点 
	}
	
	dfs(root);
	
	cout<<f[root][m]<<endl;
	
	return 0;
}

背包问题求方案数

f[i] [j] : 从前 i 个物品中选，体积恰好为 j 的方案价值最大
g[i][j] : 从前 i 个物品中选，体积恰好为 j 的取最优解的方案数

最后找到最优解的数值，在g[j]里面只要与这个数相等的都是最优方案数

因为最优解不一定是占满背包体积，所以f[m] 不一定是最优解

//背包问题求方案数 
#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=1010,mod=1e9+7;
int n,m;
int f[N],g[N];
int main(){
	cin>>n>>m;
	memset(f,-0x3f,sizeof f);
	f[0]=0;
	g[0]=1;
	for(int i=0;i<n;i++)
	{
		int v,w;
		cin>>v>>w;
		for(int j=m;j>=v;j--)
		{
			int maxv=max(f[j],f[j-v]+w);
			int s=0;
			if(f[j]==maxv) s=g[j];
			if(f[j-v]+w==maxv) s=(s+g[j-v])%mod;
			g[j]=s; 
			f[j]=maxv;
		}
	}
	
	int res=0;
	for(int i=0;i<=m;i++) res=max(res,f[i]);
	
	int cnt=0;
	for(int i=0;i<=m;i++)
	{
		if(f[i]==res)
			cnt=(cnt+g[i])%mod;
	}
	cout<<cnt<<endl;
	return 0;
}

背包问题求具体方案

#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;
    // 一定要先把体积和价值先读进来，后面再求解；因为求解的时候i是从大到小遍历的
    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]);
        }

	// f[1][m]是最大价值，一步步向后看物品i是否应该选
    for (int i = 1, j = m; 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 <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 10010;
int n;

struct Stone {
    int s, e, l;
    // 要重新定义石头的比较函数，最好写成乘法，以求精确性，并且避免0作为除数
    bool operator<(const Stone& T) const {
        return s * T.l < l * T.s;
    }
} stone[N];

// 为了空间优化，可以只开一维数组
int f[N];

int main() {
    int T;
    cin >> T;
    for (int C = 1; C <= T; C++) {
        cin >> n;
        // m存总耗时，其范围是从0到si的总和
        int m = 0;
        for (int i = 0; i < n; i++) {
            int s, e, l;
            cin >> s >> e >> l;
            stone[i] = {s, e, l};
            m += s;
        }

        sort(stone, stone + n);

        memset(f, -0x3f, sizeof f);
        f[0] = 0;

        for (int i = 0; i < n; i++) {
            int s = stone[i].s, e = stone[i].e, l = stone[i].l;
            for (int j = m; j >= s; j--) 
                f[j] = max(f[j], f[j - s] + max(0, e - (j - s) * l));
        }

        int res = 0;
        for (int i = 0; i <= m; i++) res = max(res, f[i]);
        printf("Case #%d: %d\n", C, res);
    }

    return 0;
}

金明的预算方案

题目描述

#include <iostream>
#include <vector>
using namespace std;

typedef pair<int, int> PII;

const int N = 70, M = 32010;

int n, m;
// 存主件的价格和收益
PII master[N];
// servant[i]存i号主件的价格和收益
vector<PII> servant[N];
int f[M];

int main() {
    cin >> m >> n;
    for (int i = 1; i <= n; i++) {
        int v, w, q;
        cin >> v >> w >> q;
        // q是0的话，当前物品是主件
        if (!q) master[i] = {v, v * w};
        // 否则是附件，价格是v，收益是v * w
        else servant[q].push_back({v, v * w});
    }

    for (int i = 1; i <= n; i++) 
    	// 这是0-1背包问题，体积要从大到小遍历
        for (int j = m; j >= 0; j--) {
            auto &sv = servant[i];
            // 枚举所有附件的搭配情况，用状态压缩的办法枚举
            for (int k = 0; k < 1 << sv.size(); k++) {
                int v = master[i].first, w = master[i].second;
                for (int u = 0; u < sv.size(); u++)
                    if (k >> u & 1) {
                        v += sv[u].first;
                        w += sv[u].second;
                    }
                    
                if (j >= v) f[j] = max(f[j], f[j - v] + w);
            }
        }

    cout << f[m] << endl;

    return 0;
}

货币系统

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

using namespace std;

const int N = 25010;

int n;
int a[N];
bool f[N];

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        cin >> n;
        for (int i = 0; i < n; i ++ ) cin >> a[i];
        sort(a, a + n);

        int m = a[n - 1];
        memset(f, 0, sizeof f);
        f[0] = true;

        int k = 0;
        for (int i = 0; i < n; i ++ )
        {
            if (!f[a[i]]) k ++ ;
            for (int j = a[i]; j <= m; j ++ )
                f[j] += f[j - a[i]];//属性是方案数，所以是相加
        }

        cout << k << endl;
    }

    return 0;
}

策z

关注

15
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
动态规划——背包问题优化

一般f[i][j]表示的是前i个物品中，总体积不超过(恰好)j的所有方案的最大价值。一般n表示物品种类数，m表示背包容量，v表示物品体积volume，w表示物品价值worth，s表示物品个数。背包问题核心：物品数，体积，决策（状态转移的过程）。
复制链接

扫一扫