CRP week6 周报

已于 2023-11-19 22:23:53 修改
阅读量141 收藏 1
点赞数 5
文章标签： 算法
于 2023-11-16 22:08:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cruipeng/article/details/134451062
版权

本周学bfs广度优先搜索，当题目求最短路径，最小步数等最优解问题时，优先使用bfs，因为一找到答案就可以停止搜索了；

P1135 奇怪的电梯

1.思路：非常普通的一道训练dfs的模板题。

2.代码：

#include <bits/stdc++.h>
using namespace std;
int vis[205];
int ss[2]={1,-1};
int ans[205];
int k[205];
queue<int> q;
int main()
{
	int n,a,b;
	cin>>n>>a>>b;
	memset(vis,-1,sizeof(vis));
	for(int i=1;i<=n;i=i+1)
	{
		cin>>k[i];
	}
	vis[a]=0;
	q.push(a);
	while(!q.empty())
	{
		int zx=q.front();
		q.pop();
		for(int i=0;i<2;i=i+1)
		{
			int nx=zx+ss[i]*k[zx];
			if(nx<=n&&nx>=1&&vis[nx]==-1)
			{
				vis[nx]=vis[zx]+1;
				if(nx==b)
				{
					break;
				}
				q.push(nx);
			}
		}
	}
	cout<<vis[b];
}

P1443 马的遍历

1.思路：也是一道非常easy的模板题，但因为我们需要同时储存x,y这两个坐标点，所以创建队列时queue <pair<int,int> >p,用q.push(make_pair(x,y))来将点的信息存入队列中

2.代码：

P3958 [NOIP2017 提高组] 奶酪

1.思路：感觉思路很简单，但不管怎么改都只有80分，很崩溃，先放个80分代码。（三天后：这题是真恶心啊，好吧是我太废物了，两个相乘会爆掉，需要将其转为long long）

2.代码：

#include <bits/stdc++.h>
using namespace std;
long long x[1005],y[1005],z[1005];
int vis[1005];
int d[1005][1005];
long long dist(int x1,int y1,int z1,int x2,int y2,int z2)
{
	return (long long)(x1-x2)*(x1-x2)+(long long)(y1-y2)*(y1-y2)+(long long)(z1-z2)*(z1-z2);
}
queue<int>q;
int main()
{
	int t;
	cin>>t;
	for(int k=1;k<=t;k=k+1)
	{
		while(!q.empty())
		{
			q.pop();
		}
		memset(vis,0,sizeof(vis));
		memset(d,0,sizeof(d));
		int ff=0;
		long long n,h,r;
		cin>>n>>h>>r;
		for(int i=1;i<=n;i=i+1)
		{
			cin>>x[i]>>y[i]>>z[i];
			if(abs(z[i])<=r)
			{
				vis[i]=1;
				q.push(i);
			}
		}
		for(int i=1;i<=n;i=i+1)
		{
			for(int j=i+1;j<=n;j=j+1)
			{
				if(dist(x[i],y[i],z[i],x[j],y[j],z[j])<=2*2*r*r)
				{
					d[i][j]=1;
					d[j][i]=1;
				}
			}
		}
		while(!q.empty())
		{
			int zx=q.front();
			if(abs(h-z[zx])<=r)
			{
				ff=1;
				cout<<"Yes"<<endl;
				break;
			}
			q.pop();
			for(int i=1;i<=n;i=i+1)
			{
				if(d[zx][i]==1&&vis[i]==0)
				{
					vis[i]=1;
					q.push(i);
				}
			}
		}
		if(ff==0)
		{
			cout<<"No"<<endl;
		}
	}
}

P1162 填涂颜色

1.思路：这道题是搜索里找连通块的题目，用深搜找而且不用回溯

2.代码：

P3956 [NOIP2017 普及组] 棋盘

1.思路：这道题很容易就超时了，所以我们需要进行适当的剪枝，才能够通过题目。我们可以开个d数组记录到达i,j的最小花费，每次搜索前判断花费是否小于d，否则不搜（记忆化剪枝）；还可以开个vis数组来记录i,j是否走过，如果走过就不搜（最普通的剪枝）

2.代码：

#include <bits/stdc++.h>
using namespace std;
int a[105][105];
int sx[4]={-1,0,1,0};
int sy[4]={0,1,0,-1};
int vis[105][105];
int d[105][105];
int ans=0x3f3f3f3f;
int hf;
int n,m;
int f=-1;
void dfs(int x,int y,int z)
{
	if(x==m&&y==m)
	{
		if(hf<ans)
		{
			f=1;
			ans=hf;
		}
		return;
	}
	else
	{
		for(int i=0;i<4;i=i+1)
		{
			int nx=x+sx[i];
			int ny=y+sy[i];
			if(vis[nx][ny]==0&&nx>=1&&nx<=m&&ny>=1&&ny<=m)
			{
				if(a[nx][ny]!=-1)
				{
					if(a[nx][ny]==a[x][y])
					{
						vis[nx][ny]=1;
						d[nx][ny]=hf;
						dfs(nx,ny,0);
						vis[nx][ny]=0;
					}
					else 
					{
						if(hf+1<d[nx][ny])
						{
							hf=hf+1;
							d[nx][ny]=hf;
							vis[nx][ny]=1;
							dfs(nx,ny,0);
							vis[nx][ny]=0;
							hf=hf-1;
						}
					}
				}
				else
				{
					if(z==0)
					{
						if(hf+2<d[nx][ny])
						{
							hf=hf+2;
							a[nx][ny]=a[x][y];
							vis[nx][ny]=1;
							d[nx][ny]=hf;
							dfs(nx,ny,1);
							hf=hf-2;
							vis[nx][ny]=0;
							a[nx][ny]=-1;
						}
					}
				}
			}
		}
	}
}
int main()
{
	memset(a,-1,sizeof(a));
	memset(d,0x3f3f3f3f,sizeof(d));
	cin>>m>>n;
	for(int i=1;i<=n;i=i+1)
	{
		int x,y,c;
		cin>>x>>y>>c;
		a[x][y]=c;
	}
	vis[1][1]=1;
	dfs(1,1,0);
	if(f==-1)
	{
		cout<<f<<endl;
	}
	else
	{
		cout<<ans<<endl;
	}
}

P1126 机器人搬重物

1.思路：这道题用广搜是最合适的，因为咱们找到最小的答案就可以退出了，而dfs我们很可能会因为搜索次数过多而被时间限制（剪枝了也很可能没用）。另外，坐标点在网格线上移动，所以我们需要对输入进行优化，而且状态的分类也很复杂，一共有4乘以3=12种状态。

2.代码：

#include <bits/stdc++.h>
using namespace std;
int a[55][55];
int vis[55][55][5];
int xyb[3]={1,2,3};
int fx[4]={1,2,3,4};
int qx,qy,zx,zy;
int ans=0x3f3f3f3f;
int sj=0;
int d[55][55][5];
int n,m;
int fff=-1;
void dfs(int x,int y,int z)
{
	if(x==zx&&y==zy)
	{
		fff=1;
		ans=min(ans,sj);
	}
	else
	{
		for(int i=0;i<4;i=i+1)
		{
			int nz=fx[i];
			int nx,ny;
			if(nz==1)
			{
				for(int j=0;j<3;j=j+1)
				{
					int nx=x;
					int ny=y+xyb[j];
					if(nx>=1&&nx<=n-1&&ny>=1&&ny<=m-1&&vis[nx][ny][nz]==0)
					{
						int f=1;
						for(int k=xyb[j]-1;k>=0;k=k-1)
						{
							if(a[nx][ny-k]==1)
							{
								f=0;
								break;
							}
						}
						
						if(f==0)
						{
							break;
						}
						if(f==1)
						{
							int ff=0;
							if(abs(z-nz)==2)
							{
								ff=1;
							}
							else if(z==nz)
							{
								ff=2;
							}
							if(ff==1&&sj+3<d[nx][ny][nz])
							{		
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+3;
								sj=sj+3;
								dfs(nx,ny,nz);
								sj=sj-3;
								vis[nx][ny][nz]=0;
							}
							else if(ff==0&&sj+2<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+2;
								sj=sj+2;
								dfs(nx,ny,nz);
								sj=sj-2;
								vis[nx][ny][nz]=0;
							}
							else if(ff==2&&sj+1<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+1;
								sj=sj+1;
								dfs(nx,ny,nz);
								sj=sj-1;
								vis[nx][ny][nz]=0;
							}
						}
					}
				}
			}
			if(nz==2)
			{
				for(int j=0;j<3;j=j+1)
				{
					int nx=x+xyb[j];
					int ny=y;
					if(nx>=1&&nx<=n-1&&ny>=1&&ny<=m-1&&vis[nx][ny][nz]==0)
					{
						int f=1;
						for(int k=xyb[j]-1;k>=0;k=k-1)
						{
							if(a[nx-k][ny]==1)
							{
								f=0;
								break;
							}
						}
						if(f==0)
						{
							break;
						}
						if(f==1)
						{
							int ff=0;
							if(abs(z-nz)==2)
							{
								ff=1;
							}
							else if(z==nz)
							{
								ff=2;
							}
							if(ff==1&&sj+3<d[nx][ny][nz])
							{		
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+3;
								sj=sj+3;
								dfs(nx,ny,nz);
								sj=sj-3;
								vis[nx][ny][nz]=0;
							}
							else if(ff==0&&sj+2<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+2;
								sj=sj+2;
								dfs(nx,ny,nz);
								sj=sj-2;
								vis[nx][ny][nz]=0;
							}
							else if(ff==2&&sj+1<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+1;
								sj=sj+1;
								dfs(nx,ny,nz);
								sj=sj-1;
								vis[nx][ny][nz]=0;
							}
						}
					}
				}
			}
			if(nz==3)
			{
				for(int j=0;j<3;j=j+1)
				{
					int nx=x;
					int ny=y-xyb[j];
					if(nx>=1&&nx<=n-1&&ny>=1&&ny<=m-1&&vis[nx][ny][nz]==0)
					{
						int f=1;
						for(int k=0;k<xyb[j];k=k+1)
						{
							if(a[nx][ny+k]==1)
							{
								f=0;
								break;
							}
						}
						if(f==0)
						{
							break;
						} 
						if(f==1)
						{
							int ff=0;
							if(abs(z-nz)==2)
							{
								ff=1;
							}
							else if(z==nz)
							{
								ff=2;
							}
							if(ff==1&&sj+3<d[nx][ny][nz])
							{		
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+3;
								sj=sj+3;
								dfs(nx,ny,nz);
								sj=sj-3;
								vis[nx][ny][nz]=0;
							}
							else if(ff==0&&sj+2<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+2;
								sj=sj+2;
								dfs(nx,ny,nz);
								sj=sj-2;
								vis[nx][ny][nz]=0;
							}
							else if(ff==2&&sj+1<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+1;
								sj=sj+1;
								dfs(nx,ny,nz);
								sj=sj-1;
								vis[nx][ny][nz]=0;
							}
						}
					}
				}
			}
			if(nz==4)
			{
				for(int j=0;j<3;j=j+1)
				{
					int nx=x-xyb[j];
					int ny=y;
					if(nx>=1&&nx<=n-1&&ny>=1&&ny<=m-1&&vis[nx][ny][nz]==0)
					{
						int f=1;
						for(int k=0;k<xyb[j];k=k+1)
						{
							if(a[nx+k][ny]==1)
							{
								f=0;
								break;
							}
						}
						if(f==0)
						{
							break;
						}
						if(f==1)
						{
							int ff=0;
							if(abs(z-nz)==2)
							{
								ff=1;
							}
							else if(z==nz)
							{
								ff=2;
							}
							if(ff==1&&sj+3<d[nx][ny][nz])
							{		
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+3;
								sj=sj+3;
								dfs(nx,ny,nz);
								sj=sj-3;
								vis[nx][ny][nz]=0;
							}
							else if(ff==0&&sj+2<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+2;
								sj=sj+2;
								dfs(nx,ny,nz);
								sj=sj-2;
								vis[nx][ny][nz]=0;
							}
							else if(ff==2&&sj+1<d[nx][ny][nz])
							{
								vis[nx][ny][nz]=1;
								d[nx][ny][nz]=sj+1;
								sj=sj+1;
								dfs(nx,ny,nz);
								sj=sj-1;
								vis[nx][ny][nz]=0;
							}
						}
					}
				}
			}
		}
	}
}
int main()
{
	memset(d,0x3f3f3f3f,sizeof(d));
	cin>>n>>m;
	int ffff=0;
	for(int i=1;i<=n;i=i+1)
	{
		for(int j=1;j<=m;j=j+1)
		{
			int x;
			cin>>x;
			
			if(x==1)
			{
				ffff=1;
				a[i][j]=1;
				a[i-1][j]=1;
				a[i][j-1]=1;
				a[i-1][j-1]=1;
			}
		}
	}
	cin>>qx>>qy>>zx>>zy;
	char c;
	int z;
	cin>>c;
	if(c=='E')
	{
		z=1;
	}
	if(c=='S')
	{
		z=2;
	}
	if(c=='W')
	{
		z=3;
	}
	if(c=='N')
	{
		z=4;
	}
	vis[qx][qy][z]=1;
	if(ffff==0)
	{
		cout<<32;
	}
	else
	{
		dfs(qx,qy,z);
	}
	if(fff==1&&ffff==1)
	{
		cout<<ans<<endl;
	}
	else if(fff==-1&&ffff==1)
	{
		cout<<-1;
	}
}

7-3 小源爱写题

小源现在想要加训。
他准备写 n 道题目来提高自己的算法能力。
他决定分天数（至少 2 天）完成这 n 道题目，并且每天都需要写正整数道题目。
为了提高训练效果，他规定每天写的题目数必须比上一天写的多。

输入格式:

一行一个整数，代表 n(5≤n≤500) 。

输出格式:

一个整数表示小源写完这 n 道题的所有可能方案数。

输入样例:

212

输出样例:

在这里给出相应的输出。例如：995645335

1.思路：这是一道动态规划题（好难）。我们定义状态“天数/当前总共完成的题数/前一天完成的题数”，我们可以发现天数在这道题中并不会影响总方案数（因为我们定义了状态：前一天的做题量）。另外我们求的转移方程是f[i][j]+=f[i-j][k]，其中的k表示在做i-j道题时，前一天的做题数，虽然k不是我们定义的状态，但缺少了k就缺少了关键信息，所以必须有k这一层循环。

2.代码：

#include <bits/stdc++.h>
using namespace std;
long long f[505][505];
long long ans;
int main()
{
    int n;
    cin>>n;
    f[0][0]=1;
    for(int i=1;i<=n;i=i+1)
    {
        for(int j=1;j<=i;j=j+1)
        {
            for(int k=0;k<j;k=k+1)
            {
                f[i][j]=f[i][j]+f[i-j][k];
            }
        }
    }
    for(int j=0;j<=n;j=j+1)
    {
        ans=ans+f[n][j];
    }
    cout<<ans-1;
}

cruipeng
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Crp(customizable route planning) 算法介绍
carbon06的博客
03-07 1万+
作者 crp 算法由微软硅谷研究院三名工程师于2013年提出。 设计目标 应用于大陆级别的实际路网数据 支持任意类型metric(可以理解为cost function) 响应时间满足实时查询的需求 快速的路况更新以及定制化metric更新 主要思想 实际路网由拓扑结构和metric属性两部分组成。路网拓扑结构由道路的一系列静态属性组成，包括道路长度，转向类型，车道数，道路类型...
项目实施中CRP的含义，以及各个阶段
热门推荐
NetSuite 张老师
04-12 1万+
项目实施中CRP的含义，以及各个阶段CRP (Confrence Room Pilot) 会议室模拟，模拟运行及用户化。在基本掌握软件功能的基础上，选择代表产品，将各种必要的数据录入系统，带着企业日常工作中经常遇到的问题，组织项目小组进行实战性模拟，提出解决方案。模拟可集中在机房进行，也称之为会议室模拟（conference room pilot）。我们看看维基百科对CRP的解释。Concept
CRP原理的简单例子
zqxhit1234的博客
06-23 3002
CRP:英文全名Composite Reuse Principle，译为复合的复用原则。可以解释为类应该通过复合的使用（包含实现所需功能的其他类的实例）实现多态行为和代码重用，而不是从基或父类继承。代码示例：class Employee {     BonusCalculator bc;     ... } interface BonusCalculator {     Money comput...
CRP原则
m0_69135863的博客
05-27 301
CRP原则的核心思想是优先使用组合/聚合而不是继承来实现代码复用。组合/聚合通过在类中包含其他类的实例来实现功能的扩展和复用，而不是通过继承父类来获得其功能。定义：合成复用原则（CRP）建议优先使用组合而不是继承来实现代码复用。优点：松耦合、增强复用、更符合现实世界的模型。示例：通过组合实现的报表生成更加灵活和易于维护，而通过继承实现的方式可能会增加系统的复杂性。通过遵循CRP原则，可以设计出更加灵活、可维护和可扩展的系统，减少代码的耦合度，提高代码的复用性和开发效率。
CRP实施方法论
贤时间
08-09 2296
本文转载自：https://blog.csdn.net/Jasper2008/article/details/4698339 CRP的名词解释，摘自ORACLEAIM 3.0的用户手册A75149-01的第G-10页：Conference Room Pilot (CRP): A system test in an environment set up to simulate the future production environment. 在ORACLE AIM 3.0的用户手册A75150...
CRP算法及工程实现
qq_40230900的博客
05-08 1390
路径规划及工程实现
Curl for People （crp）库介绍
热爱生活，忠于自己
04-03 2029
1、编译 crp库是在curl的基础上封装的一个使用便捷的库，linux下编译cmake比较简单。在windows下编译步骤有几点注意的地方，下面的编译会有提示。（使用版本：cpr-1.3.0，curl-7.59.0） 首先下载源码包，https://github.com/whoshuu/cpr/releases，下载之后需要在opt目录下放入依赖库 curl、googletest、mongo...
P6:合成复用原则(CRP)
芒种的农民
11-29 319
合成复用原则，Composite Reuse Principle，简称CRP. 一、定义 在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象的委派达到复用已有功能的目的。简单来说就是：尽量使用合成/聚合，尽量不要使用继承。 1、合成： 合成表示一种强的拥有关系，同生同灭。比如： 一个人新出生的人，人有两个胳膊，胳膊和人就是部分和整体的关系。人去世了，那么胳膊也就没...
有关CRP原则的学习心得
dohcsakl的博客
07-07 304
复合继承原则：又称CRP原则。类应该通过其组合（通过包含实现所需功能的其他类的实例）实现多态行为和代码重用，而不是从基类或父类继承。托可以理解为发生在对象层面上，继承则发生在类层面上。 可将委派的用法分为以下几种： 1.Dependency：临时性的委派 委派的对象作为一个参数传进方法中，其只在该方法内代码域有效，是临时的。 2.Association：永久性的delegation 委派对象为内部的一个属性，具有永久性。 3.Composition：更强的delegation
前端性能优化 CRP
hmily43的博客
07-21 504
什么是 CRP？ CRP又称关键渲染路径，引用MDN对它的解释： 关键渲染路径是指浏览器通过把 HTML、CSS 和 JavaScript 转化成屏幕上的像素的步骤顺序。优化关键渲染路径可以提高渲染性能。关键渲染路径包含了 Document Object Model (DOM)，CSS Object Model (CSSOM)，渲染树和布局。 优化关键渲染路径可以提升首屏渲染时间。理解和优化关键渲染路径对于确保回流和重绘可以每秒 60 帧、确保高性能的用户交互和避免无意义渲...
CRP软件.zip
10-27
CRP（Capacity Requirements Planning，能力需求计划）软件是企业资源规划系统中的一个重要组成部分，主要用于预测和计划生产过程中所需的能力和资源。这篇详细讲解将围绕CRP软件及其在A5打印支持下的工作站在现代...
CRP的临床意义.pptx
09-04
CRP是机体受到微生物入侵或组织损伤等炎症性刺激时肝细胞合成的急性相蛋白。 CRP在健康人血清中浓度很低（），而在细菌感染或组织损伤时，其浓度显著升高，故被认为其最有价值
CRP抗体应用技术手册.pdf
04-30
2. **心血管疾病**：高敏CRP（hs-CRP）和超敏CRP（ss-CRP）的检测有助于预测和监控心血管疾病，如心肌梗死，hs-CRP和ss-CRP的参考值远低于常规CRP。 3. **恶性肿瘤**：CRP水平在恶性肿瘤患者中通常升高，与肝癌等...
ABX crp200手册
07-10
ABX crp200手册:应用于操作与维修等。
Customizable Route Planning开源代码（CRP）
04-30
# CRP Open source C++ Implementation of Customizable Route Planning (CRP) by Delling et al. This project was part of a practical course at Karlsruhe Institute of Technology (KIT). Requirements =====...
36. Adam 算法详解
qq_41238579的博客
07-10 961
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1546
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
最新发布
m0_74586426的博客
07-12 704
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
【排序 - 堆排序】
2302_80393814的博客
07-10 548
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值