【动态规划】线性动态规划

已于 2022-09-03 21:46:16 修改
阅读量267 收藏 2
点赞数
分类专栏： 刷题笔记 文章标签： 动态规划 算法
于 2022-08-25 23:24:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzkeylucky/article/details/126534328
版权

吐槽：动态规划这个东西，只要推不出状态转移方程，一切都白搭

基础知识

一. 动态规划

动态规划中最重要的三个概念：最优子结构，重复子问题，无后效性。

  • 最优子结构：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构。
  • 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。即“现在决定未来，未来与过去无关。”
  • 重复子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。虽然该性质并不是动态规划适用的必要条件，但是如果没有这条性质，动态规划算法同其他算法相比就不具备优势

二 . 线性动态规划

线性动态规划是各种动态规划的基础，是动态规划中变化最多的一类。

线性动态规划的主要特点是状态的推导是按照问题规模 i 从小到大或从大到小依次推过去的，较大规模的问题的解依赖较小规模的问题的解。

线性动态规划针对的问题是最常见的数组，字符串，矩阵等，这三种数据结构本身就是线性的。因此出现这些类型的输入的时候，如果要用到动态规划，首先考虑线性动态规划就很合理了，因此很多问题不论最后正解是不是线性动态规划，都会首先想一下线性动态规划是否可行。

单个数组或字符串上设计一维状态，两个数组或字符串上设计两维状态，以及矩阵上设计两维状态等等，同时以上三种情况的状态设计都有可能再加上额外的判断标准的状态，这里面变化就很多了，有的题目可能会在新增的这一维上使用二分，贪心的策略，有的题目需要 DP 状态与数据结构配合来解决问题。

除此之外，还有一类问题没有显式的数组，字符串，但是在求解的时候依然满足前面提到的动态规划三条基本概念，可以用动态规划求解，这种问题通常也是线性动态规划。

背包问题也属于线性动态规划，但是由于变化较多，会拿出来专门介绍。

一 . 求最长上升子序列Longest Increasing Subsequence（LIS问题）

例题：洛谷 B3637 最长上升子序列

题目描述

给出一个由 n(n\leqslant 5000) 个不超过 10^6的正整数组成的序列。请输出这个序列的最长上升子序列的长度。

最长上升子序列是指，从原序列中按顺序取出一些数字排在一起，这些数字是逐渐增大的。

输入格式

第一行，一个整数 n，表示序列长度。

第二行有 n 个整数，表示这个序列。

输出格式

一个整数表示答案。

输入输出样例

输入 #1

6
1 2 4 1 3 4

输出 #1

4

说明/提示

分别取出 1、2、3、4 即可。

思路：

先从大循环开始，从 1 到 n，计算 f_i，记得初始化的值是 1；接下来从 1 到 i-1，即用 j 控制 i 之前的数值，如果 a_j 小于 a_i 的话，说明这个数可以和 f_i 组成上升子序列，则 f_i​ 取\max (f_i,f_j+1)，最后统计在这段序列中最长上升子序列中长度的最大值。

时间复杂度为 O(n^2) 的做法：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
const int maxn=1e6+5,INF=0x3f3f3f3f;
int a[maxn],f[maxn];
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<3)+(x<<1)+(c^48);
		c=getchar();
	}
	return x*f;
}

int main()
{
	n=read();
	for(int i=1;i<=n;++i)
	{
		a[i]=read();
		f[i]=1; //记得初始化为1；
	}
	for(int i=1;i<=n;++i)
	{
		for(int j=1;j<i;++j)
		{
			if(a[i]>a[j])
			{
				f[i]=max(f[i],f[j]+1);
			}
		}
	}
	int Max=-INF;
	for(int i=1;i<=n;++i)
	{
		if(f[i]>Max) Max=f[i];  //记录所有数据中能保证得到的最大的子序列的长度
	}
	printf("%d",Max);
	return 0;
}

二 . 求最长公共子序列 The longest common subsequence （LCS问题）

例题： 洛谷 P1439 【模板】最长公共子序列

题目描述

给出 1,2,\ldots,n 的两个排列 P_1 和 P_2​ ，求它们的最长公共子序列。

输入格式

第一行是一个数 n 。

接下来两行，每行为 n 个数，为自然数 1,2,\ldots,n 的一个排列。

输出格式

一个数，即最长公共子序列的长度。

输入输出样例

输入 #1

5 
3 2 1 4 5
1 2 3 4 5

输出 #1

3

说明/提示

  • 对于50%的数据， n \leqslant 10^3；
  • 对于100%的数据， n \leqslant 10^5。

思路：

设dp[i][j]表示两个串从1到第一个串的第 i 位，求与第二个串的第 j 位最多有多少个公共子元素

时间复杂度为 O(n^2) 的做法：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
const int maxn=1e5+5;
int a[maxn],b[maxn],dp[3005][3005];

inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

int main()
{
	n=read();
	for(int i=1;i<=n;++i)
	{
		a[i]=read();
	}
	for(int i=1;i<=n;++i)
	{
		b[i]=read();
	}
	dp[0][0]=1; //还没进行比较的时候，每一个位置只有一个数
	for(int i=1;i<=n;++i)
	{
		for(int j=1;j<=n;++j)
		{
			if(a[i] == b[j])
			{
				dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1); 
                    //与还没有进行a[i]与b[j]匹配之前的子序列数量进行比较
			}
			else
			{
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]); //继承未匹配前的最大值
			}
		}
	}
	printf("%d",dp[n][n]);
	return 0;
}

因为数据范围很大，开不了1e5*1e5的二维数组，而且相当于每一个串的每一个位置都需要比较，因此需要优化程序。

（待填坑）优化后的程序时间复杂度为 O(nlogn) 。

需要注意的是：最长公共子序列是按位向后比对的，所以a序列每个元素在b序列中的位置如果递增，就说明b中的这个数在a中的这个数整体位置偏后。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
const int maxn=1e5+5,INF=0x3f3f3f3f;
int a[maxn],b[maxn],dp[maxn],change[maxn];

inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

int main()
{
	n=read();
	for(int i=1;i<=n;++i)
	{
		a[i]=read();
		change[a[i]]=i; //记录下标
	}
	for(int i=1;i<=n;++i)
	{
		b[i]=read();
		dp[maxn]=INF;
	}
	int len=0; //最开始的最长公共子序列的长度为0
	dp[0]=0; 
	for(int i=1;i<=n;++i)
	{
		int l=0,r=len,mid;
		if(change[b[i]]>dp[len]) //如果新加入的数比子序列的最大值还要大			
		{
			dp[++len]=change[b[i]]; //直接加入到子序列中
		}
		else //利用二分查找降低复杂度
		{
			while(l<r)
			{
				mid=(l+r)>>1;
				if(dp[mid]>change[b[i]]) //缩小区间
				{
					r=mid;
				}
				else l=mid+1;
			}
		}
		dp[l]=min(dp[l],change[b[i]]); 
	}
	
	printf("%d",len);
	return 0;
}

三 . DAG中的最长路与最短路

例题：洛谷 P2583 地铁间谍 / UVA1025 城市里的间谍 A Spy in the Metro

思路：因为在时间轴上，能影响决策的只有所在时间点和当前所在的车站。

 在进行决策时可以有三种选择：1 . 在当前车站等待一分钟；2.在当前车站搭上向左行驶的列车；3.在当前车站搭上向右行驶的列车；

设dp[i][j]，下标表示时间点 i 和当前所在的车站 j ，求需要等待的最少时间；设train[i][j][0/1] ，表示在时刻 i 下，在车站 j 有一趟向右或者向左出发的列车。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n,T,num=0;
const int INF=0x3f3f3f3f;
int t[205];
int dp[2005][55];
bool train[2005][55][3];
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

int main()
{
	while(1)
	{
		n=read();
		if(n==0)
		{
		break;	
		return 0;
		}
		memset(train,0,sizeof(train));
		memset(t,0,sizeof(t));
		T=read();
		for(int i=1;i<=n-1;++i)
		{
			t[i]=read();
		}
		
		int M1=read();
		for(int i=0;i<M1;++i)
		{
			int a=read();
			for(int j=1;j<=n;++j) //记录从左往右开的列车
			{
			train[a][j][0]=1;
			a+=t[j]; //记录这一段的时间和
			}	
		}
		int M2=read();	
		for(int i=0;i<M2;++i) //记录从右往左开的列车
		{
			int b=read();
			for(int j=n;j>=1;--j)
			{
				train[b][j][1]=1;
				b+=t[j-1]; //记录时间前缀和
			}
		}
		for(int i=1;i<n;++i)
		{
			dp[T][i]=INF; //寻找最小值需要初始化为最大值
		}
		dp[T][n]=0;
		for(int i=T-1;i>=0;--i)
		{
			for(int j=1;j<=n;++j)
			{
				dp[i][j]=dp[i+1][j]+1; //停在原地
		if(j<n && train[i][j][0] && i+t[j]<=T) dp[i][j]=min(dp[i][j],dp[i+t[j]][j+1]); 
//搭上向右行驶的列车（条件解释：右边还存在站台，存在向右的列车，并且在规定时间范围内）
		if(j>1 && train[i][j][1] && i+t[j-1]<=T) dp[i][j]=min(dp[i][j],dp[i+t[j-1]][j-1]); //搭上向左行驶的列车
			}
		}
	cout<<"Case Number "<<++num<<": ";
	if(dp[0][1] >= INF) cout<<"impossible"<<endl;
	else cout<<dp[0][1]<<endl;
	}
	return 0;
}

其他无统称线性动态规划汇总

一 . 入门类线性动态规划

1 . 洛谷 P1799 数列

 思路：设dp[i][j]为：在前 i 个数中删去 j 个数后，剩余最多的符合题意的数的个数。

可以分为当前位置的数是否删去：如果删去当前位置的数，那么：dp[i][j]=dp[i−1][j−1]；若不删当前位置的数，依然分两种情况：如果这个数不符合题意：dp[i][j]=dp[i-1][j]dp[i][j]=dp[i−1][j]；如果这个数符合题意：dp[i][j]=dp[i-1][j]+1dp[i][j]=dp[i−1][j]+1。

判断条件为：当前的数值与位置下标的值是否相等即（a[i] == i - j），当前位置在操作前可能已经删减了 i 个数，也可能没有。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
bool flag;
const int maxn=1e7+5,INF=0x3f3f3f3f;
int a[maxn],dp[1005][1005],Max=-INF;
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

int main()
{
	n=read();
	for(int i=1;i<=n;++i)
	{
		a[i]=read();
	}
	dp[0][0]=0;
	for(int i=1;i<=n;++i)
	{
		for(int j=0;j<=i;++j)
		{
			if(j>0) dp[i][j]=dp[i-1][j-1]; //要注意一下j不能等于0，因为j-1前面没有数啦！
			if(a[i]==i-j) dp[i][j]=max(dp[i][j],dp[i-1][j]+1);
			else dp[i][j]=max(dp[i][j],dp[i-1][j]);
		}
	}
	
	for(int i=1;i<=n;++i)
	{
		for(int j=0;j<=n;++j)
		{
			Max=max(Max,dp[i][j]);
		}
	}
	printf("%d",Max); //查找最大值
	return 0;
}

二 . 根据某种条件选取两个数，求总情况

1 . 洛谷 P2513 [HAOI2009]逆序对数列

题目描述

对于一个数列 \{a_i\}，如果有 i<j 且 a_i > a_j，那么我们称 a_i 与 a_j​ 为一对逆序对数。若对于任意一个由 1∼n 自然数组成的数列，可以很容易求出有多少个逆序对数。那么逆序对数为 k 的这样自然数数列到底有多少个？

输入格式

第一行为两个整数n，k。

输出格式

写入一个整数，表示符合条件的数列个数，由于这个数可能很大，你只需输出该数对10000求余数后的结果。

输入输出样例

输入 #1

4 1

输出 #1

3

说明/提示

样例说明：

下列3个数列逆序对数都为1；分别是1 2 4 3 ；1 3 2 4 ；2 1 3 4；

测试数据范围

30%的数据 n \leqslant 12

100%的数据 n \leqslant 1000，k \leqslant 1000

思路：
设 f [i][j] 表示从1~ i 的数列，有 j 个逆序对。

在1 ~ i-1 的数列中插入 i 这个数，可以产生0 ~ i-1 个逆序对

所以，可以推出式子：f [i][j]=∑ f [i-1][j-k] (0 \leqslant k \leqslant i-1&& j-k\geqslant 0)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n,k;
const int maxn=1005,mod=10000;
int f[maxn][maxn];
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

int main()
{
	n=read(); k=read();
	f[0][0]=f[1][0]=1; //初始化
	for(int i=2;i<=n;++i)
	{
		int sum=0;
		for(int j=0;j<=k;++j)
		{
			(sum+=f[i-1][j])%mod;
			f[i][j]=sum%mod;
			if(j-i+1>=0) sum=(sum-f[i-1][j-i+1]+mod)%mod;
		}
	}
	printf("%d\n",f[n][k]);
	return 0;
}

三. 线段覆盖问题

在这类问题中，通常是：在一维坐标系中，给出左右节点，问线段不重合的情况下，最长能覆盖多少，一般会通过建图的思想存储线段的左右节点。

例题：洛谷 P1868 饥饿的奶牛

思路：在一些线性结构中，可以将两个端点看做图的一条边，从大的端点向小的端点连线，两点之间的距离即y-x+1看做可修改的路径长度。在这道题中即对当前稻草的向前的边所指向的稻草 的最大价值加这条边的价值取最大值，就是当前稻草时的最大价值。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
long long int n,sum=0;
const int maxn=1e7+5,INF=0x3f3f3f3f;
struct node{
	int to,next;
}edge[maxn<<1];
int head[maxn],num=0;
int dp[maxn];
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<3)+(x<<1)+(c^48);
		c=getchar();
	}
	return x*f;
}

inline void add(int u,int v)
{
	edge[++num].to=v;
	edge[num].next=head[u];
	head[u]=num;
}

int main()
{
	n=read();
	int Max=-INF;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=n;++i)
	{
		int x,y;
		x=read(); y=read();
		add(y,x); 
		if(y>Max) Max=y; //找到最大的点
	}
	for(int i=0;i<=Max;++i) //范围从0到当前所有数据的最大值
	{
		dp[i]=dp[i-1];
		for(int j=head[i];j!=-1;j=edge[j].next)
		{
			int v=edge[j].to;
		dp[i]=max(dp[i],dp[v-1]+(i-v+1)); 
        //当前节点的最大值：与当前节点相连的节点 的最大值 与这两个节点之间的距离之和
		}
	}
	
	printf("%d",dp[Max]);
	return 0;
}

变式1：已知线段的其中一个端点及线段的长度

例题：洛谷 P1280 尼克的任务

思路：在某个时间点上，尼克存在两种状态，即空闲状态和正在完成任务的状态。因为“如果在同一时刻有多个任务需要完成，尼克可以任选其中的一个来做，而其余的则由他的同事完成，反之如果只有一个任务，则该任务必需由尼克去完成，假如某些任务开始时刻尼克正在工作，则这些任务也由尼克的同事完成。”，所以第 i 时刻的最大空闲时间与后面的选择任务的持续时间有关系，那么从最后选的事情进行倒推。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm> 
using namespace std;
int n,k;
const int maxn=1e7+5;
struct node{
	int p,t;
}edge[maxn<<1];
int f[maxn],dp[maxn];
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

inline bool cmp(node x,node y)
{
	return x.p>y.p;
}

int main()
{
	n=read(); k=read();
	memset(f,0,sizeof(f));
	for(int i=1;i<=k;++i)
	{
		edge[i].p=read();
		edge[i].t=read();
		f[edge[i].p]++;  //标记这个点是否存在任务
	}
	sort(edge+1,edge+k+1,cmp);
	for(int i=n;i>=1;--i)
	{
		if(f[i]==0) //若该点不存在任务
		{
			dp[i]=dp[i+1]+1; //比前一个空闲状态下多一个空闲时间
		}
		else 
		{
			for(int j=1;j<=k;++j)
			{
				if(edge[j].p==i) //该点存在任务
				dp[i]=max(dp[i],dp[i+edge[j].t]); 
     //选出空闲时间最长的点，从p开始t秒后全部休息不了
			}
		}
	}
	printf("%d",dp[1]);
	return 0;
}

变式2：已知线段的两个端点，区间范围为左闭右开

例题：洛谷 P2439 [SDOI2005]阶梯教室设备利用

题目中要求“假设在某一演讲结束的瞬间我们就可以立即开始另一个演讲”，那么说明到达 k 时刻的时候已经算下一场演讲的范围了，所以在建图的时候，应该从 k-1 这个节点开始建立，意识到这一点其他的都跟原来的处理方式一样。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n,p,k;
const int maxn=1e7+5,INF=0x3f3f3f3f;
int dp[maxn];
struct node{
	int to,next;
}edge[maxn<<1];
int head[maxn],num=0;
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

inline void add(int u,int v)
{
	edge[++num].to=v;
	edge[num].next=head[u];
	head[u]=num;
}

int main()
{
	n=read();
	memset(head,-1,sizeof(head));
	int Max=-INF;
	for(int i=1;i<=n;++i)
	{
		p=read(); k=read();
		add(k-1,p); //！！这里建图要注意
		Max=max(Max,k);
	}

	for(int i=1;i<=Max;++i)
	{
		dp[i]=dp[i-1];
		for(int j=head[i];j!=-1;j=edge[j].next)
		{
			int v=edge[j].to;
			dp[i]=max(dp[i],dp[v-1]+i-v+1);
		}
	}
	printf("%d",dp[Max]);
	return 0;
}

变式3：已知线段的两个端点，存在区间扩大的情况

例题：洛谷 P2889 [USACO07NOV]Milking Time S

 思路：由题得：“每次 FJ 给 Bessie 挤奶之后，Bessie 都要休息 R 个小时，才能开始下一次挤奶”，那么，我们可以将休息的时间与挤奶的时间看成同一段时间，最后统计总时间段能够获得多少奶。

#include <iostream>
#include <cstring>
#include <cstring>
#include <algorithm>
using namespace std;
int n,m,r;
int start,End,ef;
const int maxn=1e7+5;
struct node{
	int to,next,w;
}edge[maxn<<1];
int head[maxn],num=0,dp[maxn];
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+(c^48);
		c=getchar();
	}
	return x*f;
}

inline void add(int u,int v,int w)
{
	edge[++num].to=v;
	edge[num].w=w;
	edge[num].next=head[u];
	head[u]=num;
}

int main()
{
	n=read(); m=read(); r=read();
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;++i)
	{
		start=read(); End=read(); ef=read();
		add(End,start,ef);
	}
	
	for(int i=0;i<=n;++i)
	{
		dp[i]=dp[i-1];
		for(int j=head[i];j!=-1;j=edge[j].next)
		{
			int v=edge[j].to;
			dp[i]=max(dp[i],dp[max(0,v-r)]+edge[j].w); 
            //注意start节点向前推长度r时，可能出现超过时间0的情况，这里需要特判
		}
	}
	printf("%d",dp[n]);
	return 0;
}

gzkeylucky
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性动态规划.docx
11-07
动态规划是在研究生入学机考、各种写代码的比赛、oj中常见的算法，非常重要，但却往往没引起我们足够的重视
多重背包（洛谷）
2201_75919055的博客
02-22 281
表示，从i件物品中选，且所选物品的总体积不超过j的所有选法的集合，然后我们再选出这些方案中最有价值的一个方案我们用。种物品，每种物品有多件，而且每种物品的体积和价值不变。枚举i种物品中选几个，假如我们选。多重背包链接（洛谷）
背包问题看这一篇就够了（详细版）
qq_54779611的博客
07-28 1万+
我们常说的背包问题其实分为好多种主要分为以下几种：01背包，完全背包，多重背包，分布背包。 所有的背包问题都是在有限V体积的背包中挑选物品，物品的属性分为w[i],v[i]表示第i个物品的价值和体积。从中找出那个能得到最大价值的选物品的方案。 通俗的来讲就是给你一个背包让你去装钻石每个钻石的价值和体积都是不一样的，最后你要装到最大价值的钻石。然后输出最大价值。 想要搞清楚这几种背包首先应该明白这几种背包的区别： 01背包 （每个物品只有一个，要么只选一个要么不选） 完全背包（每个物品有无数多个）
【acwing】5. 多重背包问题 II** & 【洛谷】 宝物筛选（二进制优化）
qq_45866781的博客
03-27 185
穿越隧道 思路很妙，太绝了。 将每种物品的S个数量，来进行合并（二进制的方式），最后经过二进制整合的物品，总体积和总价值不变，但数量从朴素遍历S件，优化成了遍历logS个物品 被自己菜哭了Q-Q #include <iostream> #include <algorithm> #include <cstring> using namespace std; const int N = 1e4 + 10, M = 2e3 + 10;//注意数据范围，N的数据范围是咋来的呀
算法数据结构——线性动态规划算法（Linear-DP）超详细总结加应用案例讲解
白话机器学习
06-08 1279
线性动态规划：具有「线性」阶段划分的动态规划方法统称为线性动态规划（简称为「线性 DP」），如下图所示。如果状态包含多个维度，但是每个维度上都是线性划分的阶段，也属于线性 DP。比如背包问题、区间 DP、数位 DP 等都属于线性 DP。线性 DP 问题的划分方法有多种方式。如果按照「状态的维度数」进行分类，我们可以将线性 DP 问题分为：一维线性 DP 问题、二维线性 DP 问题，以及多维线性 DP 问题。
动态规划（二）：最长递增子序列
qq_46231566的博客
03-15 590
描述 一个数的序列bi，当b1 < b2 < … < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, …,aN)，我们可以得到一些上升的子序列(ai1, ai2, …, aiK)，这里1 <= i1 < i2 < … < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中序列和最大为18，为子序列(1, 3, 5, 9)的和. 你的任务，
dvuewtny.zip_信号线性规划_动态规划
07-14
用MATLAB实现动态聚类或迭代自组织数据分析，线性调频脉冲压缩的Matlab程序,包含了阵列信号处理的常见算法，gmcalab 快速广义的形态分量分析，有较好的参考价值，是路径规划的实用方法，是机器学习的例程。
动态规划动态规划.zip
10-25
一、动规分类 1.线性模型 2.区间模型 3.背包模型 4.树形DP 5.数位DP 6.状态压缩DP 7.概率DP 8.图上动规 9.数据结构上动规 8.插头DP(6的一种) 9.记忆化搜索(优化)
运筹学第七章：动态规划.pdf
11-23
运筹学教程第5版第七章：动态规划的一个学习笔记。基本上是抄书，例子要少一些，主要是在抄写过程中加深记忆，同时方便以后查看。
动态规划的一些简单问题课件
11-02
动态规划初步，包括引入，01背包，分组背包，完全背包，线性dp，树形dp，区间dp，环形dp
洛谷 P1776：宝物筛选 ← 多重背包问题 二进制优化
hnjzsyjyj的专栏
08-06 527
多重背包问题通常可转化成01背包问题求解。但若将每种物品的数量拆分成多个1的话，时间复杂度会很高，从而导致TLE。所以，需要利用二进制优化思想。即： 一个正整数n，可以被分解成1,2,4,…,2^(k-1),n-2^k+1的形式。其中，k是满足n-2^k+1>0的最大整数。 例如，假设给定价值为2，数量为10的物品，依据二进制优化思想可将10分解为1+2+4+3，则原来价值为2，数量为10的物品可等效转化为价值分别为1*2，2*2，4*2，3*2，即价值分别为2，4，8，6，数量均为1的物品。......
多重背包问题---超详细讲解+优化（不懂你揍我）
热门推荐
windfriendc的博客
04-01 2万+
多重背包我们其实可以看成为01背包和完全背包的组合。但是怎么组合的呢？也可以就把多重背包问题转换成01背包问题，我们一起来看看解题思路。 1.状态表示 DP问题我们先来看状态表示 二维数组的表示，F[i][j]代表前 i 个物品中，背包容量为 j 时所能拿到的最大价值。 然后我们就看如何把多重背包转换成01背包与完全背包。 2.转换 （1）转换为01背包 我们知道，01背包问题指的是各个物品只有一件，但在多重背包问题中，我们每种物品有 Si 件。 我们可以考虑将多个同种物品合成一件物品。..
多重背包问题大全(超详细)
weixin_46503238的博客
03-25 1万+
题目: 有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 首先多重背包问题可以转换为01背包来解决,关键就是如何转换! 我们先来一种最基本的解法。 朴素解法 基本思想:比如第i件物品有s个,我可以把相同种类的物品的进行合并,比如我拿出两件合并出一个新的物品,我拿出三件合并出一个新的物品,以此类推,我拿出s个合并出一个新的物品。基于这种思想,我们把第i件的s个物品转换为s种体积各不
动态规划入门（十） 多重背包问题
Hello World!
08-05 1138
现有 N种不同的物品和一个容量为 V 的背包，已知第 i 件物品最多有件，每件物品的体积是 ，价值是 。要求在有限的背包容量下，使得装入的物品总价值最大。
洛谷P1537 弹珠【多重背包DP】【绿】
lppppppppps的博客
03-23 396
Date：2022.03.23 题目描述 玛莎和比尔各自有自己的弹珠收藏。他们想重新分配收藏品，使两人能平等拥有弹珠。如果所有的弹珠的价值相同，那么他们就可以平分。但不幸的是，有一些弹珠更大，或者更美丽，所以，玛莎和比尔给每个弹珠一个1到6的价值。现在他们想平分这些弹珠，使每个人得到的总价值相同。不幸的是，他们发现，他们可能无法以这种方式分弹珠（即使弹珠的总价值为偶数）。例如，如果有一个价值为1、一个价值为3和两个价值为4的弹珠，这样他们就不能把弹珠分为价值相等的两部分。因此，他们想要你写一个程序，告诉他们
背包问题之多重背包
WorldMvp的专栏
03-23 2250
一、多重背包问题描述 有3种物品和1个背包，背包最多只能装下15公斤的物品。怎样选择物品，使得背包能装下并且得到的价值最大。物品的重量、价值和个数如下所示： 物品编号 重量 价值 件数 物品1 3公斤 2元 4件 物品2 4公斤 3元 3件 物品3 5公斤 4元 2件 二、解题思路 我们先看下0-1背包实现原理：背包问题之0-1背包算法详解_爱思考的实践者的博客-CSDN博客。 对比分析发现，多重背包与0-1背包
【动态规划】多重背包问题详解 超详细 总结 dp
Sx_WWj的博客
03-07 1907
有n种物品和一个容量是m的背包。第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大，输出最大价值。
多重背包问题（详解二进制优化原理）
Turing_Sheep的博客
12-22 3006
推导二进制优化的过程并讲解二进制优化背后的底层原理，帮助你彻底掌握多重背包问题。
背包问题(多重背包问题)
m0_62593364的博客
02-25 210
多重背包问题对比01背包问题，01背包问题是只有选和不选两种情况，多重背包是不止这两种情况，其实是01背包问题的一种扩展，只需要在状态转移时变化一下。考虑给定一个数s,最少把s分成多少个数，分别有选和不选两种方法，可以拼成小于等于s的所有数？如果数据范围1000~2000，采用二进制优化方法：把多重背包问题变成01背包问题。解法分成log2(s)下取整个数，s=7,则拆成2^0=1,2^1=2,2^2=4。如果s=7,分成1，2，4。
贪心算法 奶牛书架c++
最新发布
12-25
贪心算法是一种在每个阶段选择局部最优解，从而希望最终能够得到全局最优解的算法。奶牛书架问题是一个典型的贪心算法应用问题。下面是一个使用C++实现的奶牛书架问题的贪心算法示例： ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; struct Book { int height; int width; }; bool compare(Book a, Book b) { return a.height > b.height; } int main() { int n; // 书的数量 cin >> n; vector<Book> books(n); for (int i = 0; i < n; i++) { cin >> books[i].height >> books[i].width; } sort(books.begin(), books.end(), compare); // 按照书的高度降序排序 int maxHeight = 0; // 当前书架的最大高度 int totalWidth = 0; // 当前书架的总宽度 int shelfCount = 0; // 书架的数量 for (int i = 0; i < n; i++) { if (totalWidth + books[i].width <= 100) { // 如果当前书可以放在当前书架上 totalWidth += books[i].width; maxHeight = max(maxHeight, books[i].height); } else { // 如果当前书无法放在当前书架上 shelfCount++; totalWidth = books[i].width; maxHeight = books[i].height; } } shelfCount++; // 最后一个书架 cout << shelfCount << " " << maxHeight << endl; return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值