动态规划（0-1、完全、多重、分组、超大背包问题）

最新推荐文章于 2024-05-05 22:37:54 发布
最新推荐文章于 2024-05-05 22:37:54 发布
阅读量983 收藏 4
点赞数 4
分类专栏： 数据结构与算法 文章标签： 程序设计 动态规划 算法
by Russellwzr
本文链接：https://blog.csdn.net/weixin_44771757/article/details/105877727
版权

个人整理的算法笔记：参考SDU程序设计思维与实践Week11-动态规划（二）+《挑战程序设计竞赛》

0-1背包问题

  • 有 N 件物品和一个容量为 V 的背包。 第 i 件物品体积是 Wi，价值是Vi。求解将哪些物品装入背包可使这些物品的体积总和不超过背包容量，且总价值最大 。
  • 特点：每种物品仅有一件，可以选择放或不放 (对应 1 或 0)。
  • 状态转移方程：
    • 设 f ( i , j ) f(i,j) f(i,j) 表示仅考虑前 i i i 件物品，放入一个容量为 j j j 的背包可以获得的最大价值
    • f ( i , j ) = m a x ( f ( i − 1 , j ) , f ( i − 1 , j − w i ) + v i ) f(i,j) = max( f(i-1,j) , f(i-1,j-w_i)+v_i) f(i,j)=max(f(i−1,j),f(i−1,j−wi​)+vi​)
  • 如果背包中的限制为容量恰好为 j j j ，则代码为
//初始化
for(int i=1;i<=V;i++)
	f[0][i]=-inf;
f[0][0]=0,ans=0;
//状态转移
for(int i=1;i<=N;i++){
	for(int j=0;j<=V;j++){
		f[i][j]=f[i-1][j];
		if(j-w[i]>=0)
			f[i][j]=max(f[i][j],f[i-1][j-w[i]]+v[i]);
	}
}
//获得答案
for(int i=0;i<=V;i++)
	ans=max(ans,f[N][i]);
  • 如果背包中的限制为容量至多为 j j j，代码为
//初始化
for(int i=0;i<=V;i++)
	f[0][i]=0;
//状态转移
for(int i=1;i<=N;i++){
	for(int j=0;j<=V;j++){
		f[i][j]=f[i-1][j];
		if(j-w[i]>=0)
			f[i][j]=max(f[i][j],f[i-1][j-w[i]]+v[i]);
	}
}
//获得答案
ans=f[N][V];
  • 滚动数组优化
  • 关键点：逆序
memset(f,0,sizeof(f));
for(int i=1;i<=N;i++)
	for(int j=V;j>=w[i];j--)
		f[j]=max(f[j],f[j-w[i]]+v[i]);
ans=f[V];
  • 复杂度
  • 时间复杂度 —— O ( N × V ) O(N×V) O(N×V)
  • 空间复杂度 —— O ( V ) O(V) O(V)

典型例题

OpenJudge2755

有一个容积为 40 的背包，给定 n n n 个物品，体积分别为 a 1 ， a 2 ， . . . ， a n a_1，a_2，...，a_n a1​，a2​，...，an​，问从这些物品中选择一些恰巧装满背包，共用多少种不同方案？

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

int n,a[30],dp[50][50];

int main()
{
	scanf("%d",&n);
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
		dp[i][0]=1;
	}
	dp[0][0]=1;
	for(int i=1;i<=n;i++){
		for(int j=0;j<=40;j++){
			dp[i][j]=dp[i-1][j];
			if(j-a[i]>=0){
				dp[i][j]+=dp[i-1][j-a[i]];
			}
		}
	}
	printf("%d\n",dp[n][40]);
	return 0;
}

POJ 3624

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
const int maxn=3402;
const int maxm=13000;
int n,m,dp[maxm];
struct bag{
	int w,d;
}a[maxn];

int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		scanf("%d%d",&a[i].w,&a[i].d);
//	for(int i=0;i<a[1].w;i++)
//		dp[i]=0;
//	for(int i=a[1].w;i<=m;i++)
//		dp[i]=a[1].d;
	memset(dp,0,sizeof(dp));
//	for(int i=2;i<=n;i++)
	for(int i=1;i<=n;i++)
		for(int j=m;j>=a[i].w;j--)
			dp[j]=max(dp[j],dp[j-a[i].w]+a[i].d);
	printf("%d\n",dp[m]);
	return 0;
}

完全背包

  • 有 N 种物品和一个容量为 V 的背包。 第 i 件物品体积是 Wi，价值是Vi。求解将哪些物品装入背包可使这些物品的体积总和不超过背包容量，且总价值最大。
  • 特点：每种物品有无数件，可以选择 0 或多件。
  • f ( i , j ) = m a x { f ( i − 1 , j ) , f ( i − 1 , j − k × w i ) + k × v i ∣ k = 0 , . . . , V / w i } f(i,j)=max\{f(i-1,j),f(i-1,j-k×w_i)+k×v_i|k=0,...,V/w_i\} f(i,j)=max{f(i−1,j),f(i−1,j−k×wi​)+k×vi​∣k=0,...,V/wi​}
memset(f,0,sizeof(f));
for(int i=1;i<=N;i++)
	for(int j=w[i];j<=V;j--)
		f[j]=max(f[j],f[j-w[i]]+v[i]);
ans=f[V];

  • 0-1背包中，采用逆序循环是为了保证物品只被选取一次，即决策选入第 i i i 件物品时，依据的时一个绝无已经选入第 i i i 件物品的子结果 f [ i − 1 ] [ j − w [ i ] ] f[i-1][j-w[i]] f[i−1][j−w[i]]

  • 现在完全背包考虑加选一个物品时，需要一个可能已经选入第 i i i 中物品的子结果，故选用正序循环。

  • 复杂度

  • 时间复杂度 —— O ( N × V ) O(N×V) O(N×V)

  • 空间复杂度 —— O ( V ) O(V) O(V)

多重背包问题

  • 有 N 件物品和一个容量为 V 的背包。 第 i 件物品体积是 Wi，价值是Vi，有 Ci 件可用，求解将哪些物品装入背包可使这些物品的体积总和不超过背包容量，且总价值最大

  • 特点：每种物品为有限件

  • f ( i , j ) = m a x { f ( i − 1 , j ) , f ( i − 1 , j − k × w i ) + k × v i ∣ k = 0 , . . . , C i } f(i,j)=max\{f(i-1,j),f(i-1,j-k×w_i)+k×v_i|k=0,...,C_i\} f(i,j)=max{f(i−1,j),f(i−1,j−k×wi​)+k×vi​∣k=0,...,Ci​}

  • 时间复杂度为 O ( V × ∑ n = 1 N C i ) O(V×\sum_{n=1}^N C_i) O(V×∑n=1N​Ci​)

  • 二进制拆分优化

    • 采用进制的思想将 C i C_i Ci​ 进行二进制拆分，然后转换为0-1背包问题。
    • 优化目标：让组数尽可能少，又能够覆盖所有决策
int cnt=0;
for(int i=1;i<=N;i++){
	int t=C[i];
	for(int k=1;k<=t;k<<=1){
		cnt++;
		vv[cnt]=k*v[i];
		ww[cnt]=k*w[i];
		t-=k;
	}
	if(t>0){
		cnt++;
		vv[cnt]=t*v[i];
		ww[cnt]=t*w[i];
	}
}
  • 处理后直接对数组 vv 和 ww 进行 0-1背包，注意 N 变为 cnt
  • 时间复杂度优化为 O ( N × V × ∑ n = 1 N l o g C i ) O(N×V×\sum_{n=1}^N logC_i) O(N×V×∑n=1N​logCi​)
  • 另附一道例题：题目链接
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;

int Cash,N,cnt,c[20],w[20],ww[10010],dp[100010];

int main()
{
	while(~scanf("%d%d",&Cash,&N)){
		cnt=0;
		for(int i=1;i<=N;i++){
			scanf("%d%d",&c[i],&w[i]);
			for(int j=1;j<=c[i];j<<=1){
				ww[++cnt]=j*w[i];
				c[i]-=j;
			}
			if(c[i]>0){
				ww[++cnt]=c[i]*w[i];
			}
		}	
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=cnt;i++){
			for(int j=Cash;j>=ww[i];j--){
				dp[j]=max(dp[j],dp[j-ww[i]]+ww[i]);
			}
		}
		printf("%d\n",dp[Cash]);
	}
	return 0;
}

分组背包问题

  • 有 N 件物品和一个容量为 V 的背包，第 i 种物品的体积是 Wi ，价值 Vi，将所有的物品划分成若干组，每个组里面的物品最多选一件。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大 。
  • 特点是：每种物品有 1 件，每组只能选 1 件
  • 状态转移方程：
  • 对于每个组：不取、取1号、…、取 s s s 号
  • 定义 f ( k , j ) f(k,j) f(k,j) 表示前 k k k 组中，容量不超过 j j j 的最大价值
  • f ( k , j ) = m a x { f ( k − 1 , j ) , f ( k − 1 , j − w u ) + v u ∣ u = 1 , . . . , s } f(k,j)=max\{f(k-1,j),f(k-1,j-w_u)+v_u|u=1,...,s\} f(k,j)=max{f(k−1,j),f(k−1,j−wu​)+vu​∣u=1,...,s}
//S表示组数，s[i]表示每组的物品数
for(int k=1;k<=S;k++){
	for(int j=0;j<=V;j++){
		for(int u=1;u<=s[k];u++){
			f[k][j]=f[k-1][j];
			if(j-w[k][u]>=0)
				f[k][j]=max(f[k][j],f[k-1][j-w[k][u]]+v[k][u]);	
		}
	}
} 
//滚动数组优化
for(int k=1;k<=S;k++)
	for(int j=V;j>=w[k][u];j--)
		for(int u=1;u<=s[k];u++)
			f[j]=max(f[j],f[j-w[k][u]]+v[k][u]);

HDU 1712

N N N 门课，有 M M M 天时间复习， a [ i ] [ j ] a[i][j] a[i][j] 表示第 i i i 门课复习 j j j 天所能获得的期望分数，问所能获得的最大分数为多少？

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn=110;
int a[maxn][maxn],dp[maxn];

int main()
{
	int N,M;
	while(~scanf("%d%d",&N,&M)){
		if(N==0&&M==0)
			break;
		for(int i=1;i<=N;i++){
			for(int j=1;j<=M;j++){
				scanf("%d",&a[i][j]);
			}
		}
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=N;i++)
			for(int j=M;j>=0;j--)
				for(int k=1;k<=j;k++)
						dp[j]=max(dp[j],dp[j-k]+a[i][k]);
		printf("%d\n",dp[M]);
	}
	return 0;
}

超大背包问题

  • 有 N 件物品和一个容量为 V 的背包。第 i 种物品的体积是 Wi ，价值 Vi。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
  • 约束：N<=500, M, Wi<=1e9, 1<=v[1]+…+v[n]<=5000
  • 思路：因为背包的容量<=1e9，会超内存，但价值的总和并不大，所以修改状态条件，定义 dp[i][j] = 选取前 i 个物品背包价值为 j 时的最小重量即可。
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;

int t,n,B,w[510],v[510],dp[5010];

int main()
{
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&B);
		int sum=0;
		for(int i=1;i<=n;i++){
			scanf("%d%d",&w[i],&v[i]);
			sum+=v[i];
		}
		memset(dp,0x3f,sizeof(dp));
		dp[0]=0;
		for(int i=1;i<=n;i++){
			for(int j=sum;j>=v[i];j--){
				dp[j]=min(dp[j],dp[j-v[i]]+w[i]);
			}
		}
		for(int i=sum;i>=0;i--){
			if(dp[i]<=B){
				printf("%d\n",i);
				break;
			} 
		}
	}
	return 0;
}
  • 若修改约束为：N <= 40, Wi <= 1e15 , Vi <= 1e15
  • 特点是：0-1 背包问题变种，体积巨大。与 DP 无关！
  • 继续依照 0 - 1背包的思路求解的话，时间复杂度和空间复杂度都无法承受
  • 思路：由于 N 很小但 V 很大，故可采用折半枚举的方法
    • 首先将物品分成两组，每组 N/2 个物品
    • 对这两组物品分别进行子集枚举，得到一系列的 <w1,v1> 二元组，代表该集合的总体积、总价值
    • 考虑单个组：
      • 如果 a[i].w1 > a[j].w1 且 a[i].v1 < a[j].v1，那么 a[i] 就可以舍去
      • 剩下的所有二元组，一定满足 a[i].w1 < a[j].w1 且 a[i].v1 < a[j].v1 ，这样就可以排序了
    • 对于排好序的两个组，假设分别为组1 和组 2，枚举组 1 的所有二元组，再于组 2 中进行二分查找，找体积小于
      V-w1 所对应的 v1 的最大值，就可以找到最大值
  • 复杂度分析
    • 分组+枚举： 2 × 2 N / 2 × ( N / 2 ) = N × 2 N / 2 2 × 2^{N/2} × (N/2) = N × 2^{N/2} 2×2N/2×(N/2)=N×2N/2
    • 后续枚举+二分： 2 N / 2 × l o g ( 2 N / 2 ) = ( N / 2 ) × 2 N / 2 2^{N/2} × log(2^{N/2}) = (N/2) × 2^{N/2} 2N/2×log(2N/2)=(N/2)×2N/2
    • 因此时间复杂度为 O ( N × 2 N / 2 ) O(N × 2^{N/2}) O(N×2N/2)
    • 代码实现（《挑战程序设计竞赛》 P163）
#include <cstdio>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn = 40 + 5;
const int INF = 10000000;
 
int n;
ll w[maxn], v[maxn];
ll W;
 
pair<ll, ll> ps[1 << (maxn / 2)];    //（重量， 价值）
void solve()
{
    //枚举前半部分
    int n2 = n / 2;
    for (int i = 0; i < 1 << n2; i++){
        ll sw = 0, sv = 0;
        for (int j = 0; j < n2; j++){
            if (i >> j & 1){
                sw += w[i];
                sv += v[i];
            }
        }
        ps[i] = make_pair(sw, sv);
    }
 
    //去除多余的元素
    sort(ps, ps + (1 << n2));
    int m = 1;
    for (int i = 1; i < 1 << n2; i++){
        if (ps[m - 1].second < ps[i].second){
            ps[m++] = ps[i];
        }
    }
 
    //枚举后半部分并求解
    ll res = 0;
    for (int i = 0; i < 1 << (n - n2); i++){
        ll sw = 0, sv = 0;
        for (int j = 0; j < n - n2; j++){
            if (i >> j & 1){
                sw += w[n2 + j];
                sv += v[n2 + j];
            }
        }
        if (sw <= W){
            ll tv = (lower_bound(ps, ps + m, make_pair(W - sw, INF)) - 1) -> second;
            res = max(res, sv + tv);
        }
    }
    printf("%lld\n", res);
}

CodeForces 1132E

八组数 ( 1 , 2 , . . . , 8 ) (1,2,...,8) (1,2,...,8)，每组数有 c n t i ( 0 ≤ c n t i ≤ 1 0 16 ) cnt_i(0≤cnt_i≤10^{16}) cnti​(0≤cnti​≤1016) 个，背包的容量为 W ( 0 ≤ W ≤ 1 0 18 ) W(0≤W≤10^{18}) W(0≤W≤1018)，问最多能装多少？

  • 同样这道题的数据量太大了，不可能直接套0-1背包的板子求解，需要进行一步转换
  • 一道思维DP，自己没想出来，参考了别人的题解，这题处理方法确实有点巧妙…
  • 1 1 1 到 8 8 8 的最小公倍数为 840 840 840，类似于贪心，按照 840 840 840 对背包进行切分，对于每一个数先优先凑成 840 840 840 的物品放进背包，剩下物品体积必然小于 840 ∗ 8 840*8 840∗8，那么答案就转化为 840 ∗ x + y 840 * x + y 840∗x+y 的形式其中 y < 840 ∗ 8 y < 840 * 8 y<840∗8，这样就只用考虑每种物品凑不够 840 840 840的情况。
  • 解法一： d p [ i ] [ j ] dp[i][j] dp[i][j]表示已经考虑完前 i i i 种物品后能否凑成重量 j j j
//https://blog.csdn.net/CSDN_PatrickStar/article/details/89761102?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-1&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-1
#include <bits\stdc++.h>
using namespace std;
typedef long long ll;
const int N = 8400;
ll cnt[9], pre[9];
ll dp[9][N];

int main() {
    ll W, sum = 0, w = 0, ans = 0;
    cin >> W;
    for(int i = 1 ; i <= 8 ; i++){
        cin >> cnt[i];
        sum += cnt[i]*i;
        pre[i] = min(1LL*840/i, cnt[i]);
        cnt[i] -= pre[i];
        w += min(cnt[i], (max(0LL, W-840)-w)/i)*i;
    }
    if(sum <= W){
        return cout << sum , 0;
    }
    dp[0][0] = 1;
    for(int i = 1 ; i <= 8 ; i++){
        for(int j = 0 ; j <= 840*8 ; j++){
            for(int k = 0 ; k <= min(pre[i], 1LL*j/i) ; k++){
                dp[i][j] = dp[i][j]|dp[i-1][j-k*i];
            }
        }
    }
    for(int j = 0 ; j <= W-w ; j++){
        if(dp[8][j]){
            ans = w+j;
        }
    }
    cout << ans << endl;
    return 0; 
}
  • 解法二：这个解法可能更好理解一些， d p [ i ] [ j ] dp[i][j] dp[i][j]表示已经考虑完前 i i i 种物品后取出 j j j 重量的物品时能获得 840 840 840 的最大份数，不用来凑 840 840 840 的部分是给 j j j 的,其他的都用来凑 840 840 840
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;

ll W,dp[10][8*840+10],cnt[10];

int main()
{
	scanf("%lld",&W);
	for(int i=1;i<=8;i++){
		scanf("%lld",&cnt[i]);
	}
	memset(dp,-1,sizeof(dp));
	dp[0][0]=0;
	for(int i=1;i<=8;i++){
		for(int j=0;j<=8*840;j++){
			int min_k=min(cnt[i],(ll)840/i);
			for(int k=0;k<=min(min_k,j/i);k++){
				if(dp[i-1][j-k*i]!=-1)
					dp[i][j]=max(dp[i][j],dp[i-1][j-k*i]+(cnt[i]-k)/(840/i));
			}
		}
	}
	ll ans=0;
	for(ll i=0;i<=8*840;i++){
		if(i<=W&&~dp[8][i])
			ans=max(ans,i+840*min(dp[8][i],(W-i)/840));	
		if(i>W)
			break;
	}
	printf("%lld\n",ans);
	return 0;
}

背包问题输出路径

题目链接

memset(dp,0,sizeof(dp));
for(int i=1;i<=M;i++){
	for(int j=0;j<=N;j++){
		dp[i][j]=dp[i-1][j];
		if(j-w[i]>=0){
			dp[i][j]=max(dp[i][j],dp[i-1][j-w[i]]+w[i]);
		}
	}		
}
int tmp=N;
for(int i=M;i>1;i--){
	if(dp[i][tmp]==dp[i-1][tmp])
		path[i]=0;
	else{
		path[i]=1;
		tmp-=w[i];
	}
}
path[1]=(dp[1][tmp]>0)?1:0;
for(int i=1;i<=M;i++){
	if(path[i])
		printf("%d ",w[i]);
}

memset(dp,0,sizeof(dp));
memset(path,0,sizeof(path));
for(int i=1;i<=M;i++){
	for(int j=N;j>=w[i];j--){
		if(dp[j]<dp[j-w[i]]+w[i]){
			dp[j]=dp[j-w[i]]+w[i];
			path[i][j]=1;
		}
	}
}
vector<int> p;
for(int i=M,m=N;i>=1&&m>=0;i--){
	if(path[i][m]){
		p.push_back(w[i]);
		m-=w[i];
	}
}
for(int i=p.size()-1;i>=0;i--)
	printf("%d ",p[i]);
Russellwzr
关注
专栏目录
算法学习笔记——动态规划 - part3
明何
08-27 4647
本部分主要是学习动态规划的一些笔记 全文下载地址：http://download.csdn.net/detail/wearenoth/6022339 1       分治法与动态规划          分治法的思路是将大问题分成若干子问题，依次求解，最后合并解的答案。但是分治法并没有说明应该划分成什么样的子问题，毕竟这不是意见容易的事情。          在分治法能够分解的问题中，有一类
动态规划：分组背包问题
xylitolz的博客
12-12 1438
文章目录往期题目解题思路空间优化Reference 往期 01背包问题 完全背包问题 多重背包问题I 多重背包问题II 混合背包问题 二维费用背包问题 题目 分组背包问题 有 NNN 组物品和一个容量是 VVV 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 每件物品的体积是 vijv_{ij}vij​，价值是 wijw_{ij}wij​，其中 iii 是组号，jjj 是组内编号。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行有两个
LeetCode 最大平均值和的分组（动态规划）
hestyle的博客
05-19 2268
我们将给定的数组 A 分成 K 个相邻的非空子数组 ，我们的分数由每个子数组内的平均值的总和构成。计算我们所能得到的最大分数是多少。 注意我们必须使用 A 数组中的每一个数进行分组，并且分数不一定需要是整数。 示例: 输入: A = [9,1,2,3,9] K = 3 输出: 20 解释: A 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) ...
0-1背包问题，完全背包，多重背包
qq_62767608的博客
01-14 409
问题引入：在做- [P2392 kkksc03考前临时抱佛脚]时感觉它应该是个跟动态规划有关的题，但是我的动态规划相当的垃圾，连0-1背包都不会，于是就去从0-1背包开始学起。0-1背包指的是给出若干物品的价值和重量，每个物品只有一个，要求用一定的背包容量装物品后的最大价值。可以先看个表格观察对于第i件物品来说：w[i]（重量）>c（背包容量）:放不下，最大价值= i-1件物品讨论时的最大价值w[i]...............
动态规划 背包九讲 01背包的分组背包问题
林黛玉到拔垂杨柳的博客
08-31 344
分组背包问题 有 N 组物品和一个容量是 V 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。 接下来有 N 组数据： 每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量； 每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分
动态规划之0-1背包问题（详解+分析+原码）
热门推荐
未见花闻的博客
05-08 4万+
本篇文章将介绍算法专题之动态规划中的背包问题，更准确的说是背包问题中最简单的一种类型，即0-1背包问题，就是给你一定容量的背包和若干物品，每种物品只能选一次，告诉你每件物品的价值和体积，求背包里面物品的最大总价值。
动态规划 ------ 背包问题
最新发布
layfolk的博客
05-05 1095
背包问题是动态规划中非常典型的一些题，本篇文章记录总结一下在学习过程中所遇到的一些背包问题。其实主要就是3种,01,完全,多重背包问题，这三种详细一些，认真搞懂了，剩下的就是这三种的变种了，换汤不换药？
【动态规划】--多重背包问题和分组背包问题
lsz014775的博客
01-27 1028
【动态规划】---多重背包问题和分组背包问题
【笔记】动态规划（2）---多重背包和分组背包
kanawi的博客
01-10 443
01背包、完全背包、分组背包、多重背包问题的关键都是两个状态的更新
0-1背包问题：动态规划 python 空间优化
linweieran的博客
09-06 3877
0-1背包问题总述 0-1背包问题是最简单的问题，此外还要完全背包问题、多重背包问题、混合背包问题、二维费用背包问题、分组背包问题等等。好的参考资料可以见《背包问题九讲》：https://www.kancloud.cn/kancloud/pack/70124 其中0-1背包问题是最基本的问题，其问题描述如下： 给出n个珍珠的体积v[i]和其价值price[i]，将他们装入一个大小为C的背包，...
算法CJ2-09-动态规划之-多重混合，分组，二维费用背包问题 .pdf
02-17
本知识点聚焦于动态规划中的多重、混合及分组二维费用背包问题，这类问题通常涉及多个维度的成本考虑以及特定的组合规则。 ##### 基本概念 - **多重背包**：每个物品可以被多次选择。 - **混合背包**：物品可以...
算法-动态规划- 背包问题 P06- 分组背包（包含源程序）.rar
09-16
分组背包问题与普通的0/1背包、完全背包和多重背包不同，它的特点在于物品可以被分为若干组，每组内的物品可以任意选择，但每组物品只能选择一次。 分组背包问题通常有以下元素： 1. 物品：每个物品有自己的价值和...
应用竞赛树结构模拟实现外排序（C++实现）
Keep eating codes!
07-25 3684
基本要求 （1）设计实现最小输者树结构 ADTADTADT，ADTADTADT 中应包括初始化、返回赢者、重构等基本操作。 （2）设计实现外排序，外部排序中的生成最初归并串以及 KKK 路归并都用最小输者树结构实现； （3）随机创建一个较长的文件；设置归并路数以及缓冲区的大小；获得外排序的访问磁盘的次数并进行分析,可采用小文件来模拟磁盘块。 问题分析 （1）设计并实现最小输者树 （2）应用最小输者树结构实现生成初始顺串 （3）应用最小输者树结构实现 KKK 路归并 （4）随机生成较长文件，设置归并路数以及缓
森林与二叉树之间的转换以及可视化演示（C++实现）
Keep eating codes!
07-25 2582
演示程序截图 基本要求 构造并实现森林的ADT和二叉树ADT，森林ADT中应包括初始化、插入元素、删除元素，插入边，删除边，转换成二叉树，显示森林及对应的二叉树等基本操作，二叉树ADT中应包括初始化、插入根、插入指定元素的左孩子或右孩子，转换成森林，显示二叉树及对应的森林等基本操作。(基本操作可根据问题需要扩展) 森林使用孩子链表表示，二叉树使用二叉链表表示，实现森林和二叉树结构。 问题分析 该程序所应实现的功能如下： （1）二叉树与森林的初始化 （2）二叉树与森林的插入操作（二叉树插入结点、森林插入
跳表的实现、分析以及可视化（Qt C++、Graphviz）
Keep eating codes!
07-25 2342
演示程序截图 实现功能 跳表初始化 跳表的查找操作 跳表的插入操作 跳表的删除操作（指定关键字的元素、关键字最小的元素、关键字最大的元素） 跳表可视化 程序结构设计 初始化模块：void Initialization(int n); 查找模块：void find(const K&); 插入模块：void insert(const pair<const K, E>&); 删除模块： 指定关键字的元素：void erase(const K&); 关键字最小的元素：v
分治算法：残缺棋盘可视化（Qt C++）
Keep eating codes!
07-25 2124
演示程序截图 问题描述 残缺棋盘(defective chessboard)：是一个有 2k×2k2^k×2^k2k×2k 个方格的棋盘，其中恰有一个方格残缺。对于任意 kkk，恰好存在 22k2^{2k}22k 种不同的残缺棋盘。 在残缺棋盘中，要求用三格板(triominoes)覆盖残缺棋盘。在覆盖中，任意两个三格板不能重叠，任意一个三格板不能覆盖残缺方格，但三格板必须覆盖其他所有方格。 基本要求 输入棋盘大小和残缺方格的位置,输出覆盖后的棋盘。 输出棋盘时要着色，共享同一边界的覆盖应着不同的颜
自顶向下伸展树（Splay Tree）的实现、分析以及可视化（C++）
Keep eating codes!
07-25 1322
演示程序截图 问题描述 伸展树是一种二叉搜索树，伸展树具有的特点是：当某个节点被访问时，伸展树会通过旋转使该节点成为树根。 基本要求 （1）设计并实现伸展树 (Splay Tree) 的 ADT，该 ADT 包括 Tree 的组织存储以及其上的基本操作：包括初始化，查找，插入和删除，拆分和合并等。并分析基本操作的时间复杂性。 （2）实现伸展树(Splay Tree ) ADT 的基本操作演示（鼓励应用图形界面）。 （3）采用伸展树，编写一个计算文本文件中单词的出现频率的程序并通过实验结果验证伸展树 (Sp
动态规划（线性、坐标型）
Keep eating codes!
06-26 347
引入 POJ - 1163 The Triangle 在给定的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。（三角形的行数大于1小于等于100，数字为 0 - 99） Sample Input 5 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 Sample Output 30 解题思路 D(i,j)D(i,j)D(i,j...
动态规划详解：背包问题九讲
"背包问题九讲，作者ddengi，旨在阐述动态规划中的背包问题，包括0-1背包、完全背包、多重背包等经典问题，并探讨其变化形式与解题策略。" 背包问题在信息技术竞赛（如NOIP）和算法设计中具有重要地位，因为它能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值