简单动态规划(1)——从入门到放弃

最新推荐文章于 2024-04-20 21:48:55 发布
最新推荐文章于 2024-04-20 21:48:55 发布
阅读量467 收藏
点赞数
分类专栏： 从入门到放弃——被遗忘的知识点名录 OI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Friedrich_Taylor/article/details/78116222
版权
本文介绍了动态规划的基础知识，从经典的01背包、完全背包、多重背包问题入手，并通过实例详细解析了二维费用的多重背包问题。接着，文章探讨了树形DP，包括骑士问题和仙人掌图问题，通过具体题目帮助读者理解树形DP的解题思路。
摘要由CSDN通过智能技术生成

前言

这一篇完全是迫于鸭梨强行凑的一篇...

因为作者实在是太蒻了，看到AseanA大佬怒虐DP之后就产生了诸如“我也能A动态规划题”之类的妄想，于是莫名其妙地捡起一堆题就开始乱淦一波。

(然后理所当然地被虐成沙茶)

经典的背包问题

很显然有三种著名背包：01,完全与多重

当然多维费用也算

所以我直接甩一个链接应该比较好点击打开链接

我们当然会直接上习题辣

水得如尼亚加拉瀑布一样的水题

（1）暗黑游戏

二维费用，多重背包，拿来当模板真的很妙

甩一个题面点击打开链接

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline int read(){
	int i=0,f=1;
	char ch;
	for(ch=getchar();!isdigit(ch);ch=getchar())
		if(ch=='-') f=-1;
	for(;isdigit(ch);ch=getchar())
		i=(i<<3)+(i<<1)+(ch^48);
	return i*f;
}
int buf[1024];
inline void write(int x){
	if(!x){putchar('0');return ;}
	if(x<0){putchar('-');x=-x;}
	while(x){buf[++buf[0]]=x%10,x/=10;}
	while(buf[0]) putchar(buf[buf[0]--]+48);
	return ;
}
#define stan 222
int n,p,r,pn[stan],rn[stan],s[stan],t[stan],f[stan][stan];
signed main(){
	n=read();p=read();r=read();
	for(int i=1;i<=n;++i){
		pn[i]=read();rn[i]=read();s[i]=read();t[i]=read();
	}
	for(int i=1;i<=n;++i)
		if(s[i]==0)
			for(int j=pn[i];j<=p;++j)
				for(int k=rn[i];k<=r;++k)
					f[j][k]=max(f[j][k],f[j-pn[i]][k-rn[i]]+t[i]);
		else
			for(int j=p;j>=pn[i];--j)
				for(int k=r;k>=rn[i];--k)
					for(int l=1;l*pn[i]<=j&&l*rn[i]<=k&&l<=s[i];++l)
						f[j][k]=max(f[j][k],f[j-l*pn[i]][k-l*rn[i]]+l*t[i]);
	write(f[p][r]);
	return 0;
}


（2）质数和分解

甩一个链接点击打开链接

因为我们在讲背包，嗯，很显然，这就是一个背包

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline int read(){
	int i=0,f=1;
	char ch;
	for(ch=getchar();!isdigit(ch);ch=getchar())
		if(ch=='-') f=-1;
	for(;isdigit(ch);ch=getchar())
		i=(i<<3)+(i<<1)+(ch^48);
	return i*f;
}
int buf[1024];
inline void write(int x){
	if(!x){putchar('0');return ;}
	if(x<0){putchar('-');x=-x;}
	while(x){buf[++buf[0]]=x%10,x/=10;}
	while(buf[0]) putchar(buf[buf[0]--]+48);
	return ;
}
#define stan 222
int cnt,n,f[stan],pri[stan];
bool exi[stan];
void preact(){
	for(int i=2;i<=200;++i){
		if(!exi[i])
			pri[++cnt]=i;
		for(int j=1;j<=cnt&&i*pri[j]<=200;++j){
			exi[i*pri[j]]=true;
			if(i%pri[j]==0) break;
		}
	}
	return ;
}
signed main(){
	preact();
	while(scanf("%d",&n)!=EOF){
		memset(f,0,sizeof(f));
		f[0]=1;
		for(int i=1;i<=cnt;++i)
			for(int j=pri[i];j<=n;++j)
				f[j]+=f[j-pri[i]];
		write(f[n]);puts("");
	}
	return 0;
}


（3）墨墨的等式

题面照例见链接

很显然我们可以知道对于一个重量为ai的包，Xi表示的是这个背包被选择的次数

这就是一个无限背包求可行方案数问题了

同时考虑到对于一个权值bi为最小满足ai*bi+x是可行解(x为给定权值)，那么自然ai*(bi+1)+x均可凑

然后转化成最短路即可

参考文献点击打开链接

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#include<queue>
#define int long long
using namespace std;
inline int read(){
	int i=0,f=1;
	char ch;
	for(ch=getchar();!isdigit(ch);ch=getchar())
		if(ch=='-') f=-1;
	for(;isdigit(ch);ch=getchar())
		i=(i<<3)+(i<<1)+(ch^48);
	return i*f;
}
int buf[1024];
inline void write(int x){
	if(!x){putchar('0');return ;}
	if(x<0){putchar('-');x=-x;}
	while(x){buf[++buf[0]]=x%10,x/=10;}
	while(buf[0]) putchar(buf[buf[0]--]+48);
	return ;
}
#define stan 555555
#define sten 5555555
#define stin 22
priority_queue<pair<int,int> >que;
int tot,first[stan],goal[sten],nxt[sten],dis[sten],to[stan],vis[stan],n,l,r,a[stin],cnt1,cnt2,ans;
void addedge(int a,int b,int c){
	nxt[++tot]=first[a];first[a]=tot;goal[tot]=b;dis[tot]=c;
	return ;
}
void dijkstra(){
	for(int i=0;i<a[1];++i)
		to[i]=999999999999999;
	to[0]=0;
	que.push(make_pair(-to[0],0));
	while(!que.empty()){
		int u=que.top().second;que.pop();
		if(vis[u]) continue;
		vis[u]=true;
		for(int p=first[u];p;p=nxt[p])
			if(to[goal[p]]>to[u]+dis[p]){
				to[goal[p]]=to[u]+dis[p];
				que.push(make_pair(-to[goal[p]],goal[p]));
			}
	}
	return ;
}
signed main(){
	n=read();l=read();r=read();
	for(int i=1;i<=n;++i)
		a[i]=read();
	sort(a+1,a+n+1);
	for(int i=0;i<a[1];++i)
		for(int j=2;j<=n;++j)
			addedge(i,(a[j]+i)%a[1],a[j]);
	dijkstra();
	for(int i=0;i<a[1];++i)
		if(to[i]<=r){
			cnt1=max((int)0,(l-to[i])/a[1]);
			if(cnt1*a[1]+to[i]<l) ++cnt1;
			cnt2=(r-to[i])/a[1];
			if(cnt2*a[1]+to[i]>r) --cnt2;
			ans+=cnt2-cnt1+1;
		}
	write(ans);
	return 0;
}

树形DP

那啥我觉得树形DP还是比线性DP好理解得多

水得如下开水一样的水题

所以我们还是直接上题比较妙

（1）骑士(ZJOI2008)

传送门

总觉得这是一道环状DP，找到环之后两个人分别怼一遍即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#define int long long
using namespace std;
inline int read(){
	int i=0,f=1;
	char ch;
	for(ch=getchar();!isdigit(ch);ch=getchar())
		if(ch=='-') f=-1;
	for(;isdigit(ch);ch=getchar())
		i=(i<<3)+(i<<1)+(ch^48);
	return i*f;
}
int buf[1024];
inline void write(int x){
	if(!x){putchar('0');return ;}
	if(x<0){putchar('-');x=-x;}
	while(x){buf[++buf[0]]=x%10,x/=10;}
	while(buf[0]) putchar(buf[buf[0]--]+48);
	return ;
}
#define stan 1111111
int tot,nxt[stan],first[stan],goal[stan],fa[stan],val[stan],f[stan][2],tag[stan];
int ans,n,b;
bool vis[stan]; 
void addedge(int a,int b){
	nxt[++tot]=first[a];first[a]=tot;goal[tot]=b;
	fa[b]=a;
	return ;
}
void dfs(int u){
	vis[u]=true;
	f[u][1]=val[u];
	for(int p=first[u];p;p=nxt[p])
		if(!vis[goal[p]]){
			dfs(goal[p]);
			f[u][0]+=max(f[goal[p]][0],f[goal[p]][1]);
			f[u][1]+=f[goal[p]][0];
		}
	return ;
}
void dp(int pos){
	int root;
	for(root=pos;tag[root]!=pos;root=fa[root])
		tag[root]=pos;
	dfs(root);
	int nx=fa[root];
	f[nx][1]=f[nx][0];
	for(nx=fa[nx];nx!=root;nx=fa[nx]){
		f[nx][1]=val[nx];f[nx][0]=0;
		for(int p=first[nx];p;p=nxt[p]){
			f[nx][0]+=max(f[goal[p]][1],f[goal[p]][0]);
			f[nx][1]+=f[goal[p]][0];
		}
	}
	f[root][1]=val[root];
	for(int p=first[root];p;p=nxt[p])
		f[root][1]+=f[goal[p]][0];
	ans+=max(f[root][0],f[root][1]);
	return ;
}
signed main(){
	n=read();
	for(int i=1;i<=n;++i){
		val[i]=read();
		b=read();
		addedge(b,i);
	}
	for(int i=1;i<=n;++i)
		if(!vis[i]) dp(i);
	write(ans);
	return 0;
}

（2）仙人掌图(SHOI2008)

“这世间所有的相遇，都是久别重逢”——宫二

Intro

通过这道题我们可以发现，原来世间所有省选的树形DP，都是带了环的

甩一个大佬的链接outro

讲个笑话，我原封不动地照抄了大佬的代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline int read(){
	int i=0,f=1;
	char ch;
	for(ch=getchar();!isdigit(ch);ch=getchar())
		if(ch=='-') f=-1;
	for(;isdigit(ch);ch=getchar())
		i=(i<<3)+(i<<1)+(ch^48);
	return i*f;
}
int buf[1024];
inline void write(int x){
	if(!x){putchar('0');return ;}
	if(x<0){putchar('-');x=-x;}
	while(x){buf[++buf[0]]=x%10,x/=10;}
	while(buf[0]) putchar(buf[buf[0]--]+48);
	return ;
}
#define stan 55555
#define sten 2222222
int n,m,tot,k,a,b;
int nxt[sten],first[stan],goal[sten],copf[stan<<1],f[stan];
int low[stan],dfn[stan],ts,l,r,ans,dep[stan];
int fa[stan],q[stan<<1];
void addedge(int a,int b){
	nxt[++tot]=first[a];first[a]=tot;goal[tot]=b;
	nxt[++tot]=first[b];first[b]=tot;goal[tot]=a;
	return ;
}
void dp(int root,int x){
	int tota=dep[x]-dep[root]+1;
	for(int u=x;u!=root;u=fa[u])
		copf[tota--]=f[u];
	copf[tota]=f[root];
	tota=dep[x]-dep[root]+1;
	for(int i=1;i<=tota;++i)
		copf[i+tota]=copf[i];
	q[1]=1;l=r=1;
	for(int i=2;i<=2*tota;++i){
		while(l<=r&&i-q[l]>tota/2) ++l;
		ans=max(ans,copf[i]+i+copf[q[l]]-q[l]);
		while(l<=r&&copf[q[r]]-q[r]<=copf[i]-i) --r;
		q[++r]=i;
	}
	for(int i=2;i<=tota;++i)
		f[root]=max(f[root],copf[i]+min(i-1,tota-i+1));
	return ;
}
void tarjan(int u){
	low[u]=dfn[u]=++ts;
	for(int p=first[u];p;p=nxt[p])
		if(goal[p]!=fa[u]){
			if(!dfn[goal[p]]){
				fa[goal[p]]=u;
				dep[goal[p]]=dep[u]+1;
				tarjan(goal[p]);
				low[u]=min(low[u],low[goal[p]]);
			}
			else 
				low[u]=min(low[u],dfn[goal[p]]);
			if(dfn[u]<low[goal[p]]){
				ans=max(ans,f[u]+f[goal[p]]+1);
				f[u]=max(f[u],f[goal[p]]+1);
			}
		}
	for(int p=first[u];p;p=nxt[p])
		if(fa[goal[p]]!=u&&dfn[u]<dfn[goal[p]])
			dp(u,goal[p]);
	return ;
}
signed main(){
	n=read();m=read();
	for(int i=1;i<=m;++i){
		k=read();a=read();
		for(int j=2;j<=k;++j){
			b=read();
			addedge(a,b);
			a=b;
		}
	}
	tarjan(1);
	write(ans);
	return 0;
}

（3）河流

对这道题的存在就是打我脸的

题解我已经懒到不想写了。

我绝对不知道这是一个记忆化外带多叉转二叉

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline int read(){
	int i=0,f=1;
	char ch;
	for(ch=getchar();!isdigit(ch);ch=getchar())
		if(ch=='-') f=-1;
	for(;isdigit(ch);ch=getchar())
		i=(i<<3)+(i<<1)+(ch^48);
	return i*f;
}
int w[200],v[200],d[200],n,k,f[200][100][200],lc[200],rc[200],son[200];
void dfs(int pos){
	for(int u=lc[pos];u;u=rc[u]){
		d[u]+=d[pos];
		dfs(u);
	}
	return;
}
int work(int pos,int remain,int root){
	int temp=0;
	if(f[pos][remain][root]!=-1) return f[pos][remain][root];
	f[pos][remain][root]=999999999;
	for(int k=0;k<=remain;++k){
		temp=w[pos]*(d[pos]-d[root]);
		if(lc[pos]) temp+=work(lc[pos],k,root);
		if(rc[pos]) temp+=work(rc[pos],remain-k,root);
		f[pos][remain][root]=min(f[pos][remain][root],temp);
		if(k<remain){
			temp=0;
			if(lc[pos]) temp+=work(lc[pos],k,pos);
			if(rc[pos]) temp+=work(rc[pos],remain-k-1,root);
			f[pos][remain][root]=min(f[pos][remain][root],temp);
		}
	}
	return f[pos][remain][root];
}
signed main(){
	n=read();k=read();
	for(int i=1;i<=n;++i){
		w[i]=read();
		v[i]=read();
		d[i]=read();
		if(!son[v[i]]) lc[v[i]]=i;
		else rc[son[v[i]]]=i;
		son[v[i]]=i;
	}
	memset(f,255,sizeof(f));
	dfs(0);
	cout<<work(0,k,0);
	return 0;
}


局部完结撒花



Friedrich_Taylor
关注
专栏目录
简单动态规划（真的简单）
qq_39561693的博客
12-04 1251
简单动态规划（Dynamic Programming） 在解决一些最优解问题时，我们经常会需要进行动态规划的求解，以期望避免暴力搜索消耗的超长时间.
Golang——从入门到放弃
热门推荐
m0_67401228的博客
07-31 4万+
Go是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易Go是从2007年末由RobertGriesemer,RobPike,KenThompson主持开发，后来还加入了IanLanceTaylor,RussCox等人，并最终于2009年11月开源，在2012年早些时候发布了Go1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。中文网在线标准库文档。...
简单的动态规划
mryang125的博客
01-17 1万+
认识动态规划 以下是一段描述斐波那契数列的简单代码。本质是一个递归的方案，它的计算过程是不断的将大计算拆分成小计算，最后再对小计算的结果进行合并。然而递归方案的时间复杂度非常高，为O(2^n)。当n非常大的时候会产生高昂的时间成本。 /** * 经典的fabonacci问题，1 1 2 3 5 8 13 21... * 使用递归算法实现，本质是一种分治策略，自顶向下。 * 不断的将大计算拆分成小计算，最后再对小计算的结果进行合并。 * 递归的缺点是不能复用小计算的结果，导致时间复
简单动态规划
weixin_42105529的博客
04-11 218
Square Coins ZOJ - 1666 People in Silverland use square coins. Not only they have square shapes but also their values are square numbers. Coins with values of all square numbers up to 289 (=17^2),...
简单版的动态规划
野狼
04-02 2054
问题描述 小北很喜欢玩计算机游戏，特别是战略游戏，但是有时他不能尽快找到解所以常常感到很沮丧。现在面临如下问题：他必须在一个中世纪的城堡里设防，城堡里的道路形成一棵无向树。要在结点上安排最少的士兵使得他们可以看到所有边。你能帮助他吗？ 你的任务是给出士兵的最少数目。 输入格式 输入包含多组数据。每组数据表示一棵树，在每组数据中： 第一行是结点的数目。 接下来的几行，每行按如下
SQL Server——从入门到放弃（16）– 第十章：数据库恢复技术 课后习题
12-14
在SQL Server的学习旅程中，数据库恢复技术是至关重要的一环，它关乎着数据的安全性和可用性。本章节我们将探讨几个关键的知识点，以帮助...通过不断的练习和实践，我们可以从“入门”逐步迈向精通，而不是“放弃”。
SQL Server——从入门到放弃（13）– 第七章： 数据库设计 课后习题
12-14
1. **系** (系号, 系名, 学校名) 2. **班级** (班号, 班名, 系号) 3. **教研室** (教研室编号, 教研室名称, 系号) 4. **学生** (学号, 姓名, 学历, 班号, 系号, 教员编号) 5. **教员** (教员编号, 姓名, 职称, 教研...
简单动态规划(2)——从入门到放弃
Friedrich_Taylor的博客
09-28 507
前言 又强行凑了一波... 今天我们来讲区间，状压和数位 区间DP的水题 已经不打算写任何概论了XD （1）压缩(SCOI2007) 题面见链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1068 对于每一个区间(l,r)我们都可以进行如下操作： 如果这个区间可以在i处被分成两段进行压缩，那么我们更新的结果就是f[l][i]+f
HDOJ 5569matrix (简单动态规划)
test
11-25 617
matrix Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 410    Accepted Submission(s): 245 Problem Description Given a matrix with n
动态规划初学的简单例子
01-31
几个简单的动态规划的例子，有原题，有现成代码，对于初学者应该会很有用出
动态规划简单实例
天行健
07-30 555
选的是PKJ1163 题 The Triangle。思路很简单，能够体现动态规划的一般思路。Description73   88   1   02   7   4   44   5   2   6   5(Figure 1)Figure 1 shows a number triangle. Write a program that calculates the highest sum of numbers passed on a route that starts at the top and ends s
算法--简单动态规划(简单dp)
程天爽的博客
02-10 1146
初级dp，介绍了三种模型，组合模型，路线模型和线性模型，以及对应练习题
**简单整理动态规划**
YSJ367635984的博客
02-03 397
只有失败才能看清自己与世界
简单动态规划集（五）
云之巅
03-25 646
最长公共子序列 给两个字符串，让你求最长公共子串 这也是个简单的动态规划，用二维的更容易理解 当str1[i]=str[j] c[i][j]=c[i-1][j-1]+1 否则c[i][j]=max(c[i-1][j],c[i][j-1]) 用一维可以省内存只需记录下需要的c[i]就行了 #include #include #define N 1006 int c[N]; ch
简单动态规划集（二）
云之巅
03-25 637
最大子串和 题意：给定一整型数列{a1,a2...,an}，找出连续非空子串{ax,ax+1,...,ay}，使得该子序列的和最大，其中，1 对于这道题我们最简单的思路，把所有子串都找出来，然后找个最大的，如果我们真的这样做了，复杂度有点高，难度有点大了 我们这样想一下，这个子串是连续的，我们这样想一下如果，一段子串和小于0，我们回去要吗？答案是否定的，我们坚决不要 那这样就好了，我们
简单动态规划(4)——从入门到放弃
Friedrich_Taylor的博客
09-30 369
期望DP对我们今天是来切水题的 （1）博物馆(BZOJ3270) 题面还是见黄学长的博客吧传送门 因为这里有环形，我们显然不能直接向傻X一样递推 我们定义id[x][y]id[x][y]表示一人在x，一人在y的状态 再标记d[x]d[x]为点xx的度 ratio[x]ratio[x]为不转移的概率 然后mat[id[x1][y1]][id[x2][y2]]mat[id[x_1][y_1
动态规划（入门）
littlest_white的博客
10-13 628
最经典的递归算法，但是我们知道，递归的逐层嵌套是存在很大弊端的，我们能否对其进行一定的改进呢？既然我们只需要第n层的方法，而求第n层只需要求前两层的方法，那我们把之前全部的方法数存起来干什么？既然每一层的方法都受前面层数的影响，那么我们不妨将每层所需的方法数存在一个数组里，这样以来要求哪一层就直接从数组里调就好了。如此推得，爬n层楼梯的方法数不就是爬n-1层楼梯的方法数+爬n-2层楼梯的方法数吗？以上是两道最为基础的动态规划问题，如果你已经学会了，那就快去找几道经典的动态规划问题去试试手吧！
动态规划简单类型整理
最新发布
qq_55417658的博客
04-20 980
动态规划是一种穷举算法，通常基于一个递推公式和一个或多个初始状态。当前问题的解可以分解为多个子问题解得出。使用动态规划只需要多项式时间复杂度，因为比回溯法和暴力法快很多，体现了以空间换时间的算法思想适用动态规划问题的特点：1.最优子结构，将母问题分解为子问题后，当子问题最优时，母问题通过优化选择一定最优的情况（或者说成母问题的最优解可由子问题的最优解构建得到）2.重复子序列，不同的决策序列，到达某个相同的阶段时，可能会产生相同的状态。
spark从入门到放弃——初识spark（一）
03-16
以下是我对“spark从入门到放弃——初识spark（一）”的回答： “spark从入门到放弃”是一个非常有趣的话题，而“初识spark（一）”则是其中的第一篇文章。在这篇文章中，作者主要介绍了Spark的基本概念和特点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值