【蓝桥杯 第十一届 决赛题目】出租车（SPFA+大模拟）

已于 2022-11-14 17:21:02 修改
阅读量1.4k 收藏 7
点赞数 5
分类专栏： C++ 蓝桥杯 算法：大模拟 算法：图论 文章标签： 蓝桥杯 算法 宽度优先
于 2022-02-07 19:48:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l961983207/article/details/122813788
版权

题目

题目链接

题目简介

一个需要等红绿灯的最短路设计问题

法一： dfs暴力（20分）

时间复杂度 O(2^n)
代码即备注：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
//数据范围：n,m<=100; q<=30; h,w<=1e5; g,r<=1000; 
inline int read(){
	char ch=getchar();int sum=0;
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9')
		sum*=10,sum+=ch-'0',ch=getchar();
	return sum;
} 
#include<cmath>
//当前位置信息 
int up=0,rright=1,down=2,lleft=3;
int h[105],w[105];int n,m;
struct s1{
	int x1,y1,x2,y2;
	int dierction;double dis;
	double mid_x,mid_y;
	void dir(){//判断pos.dierction 
		if(x1==x2){
			if(y1>y2) dierction=lleft;
			else dierction=rright;
		}
		if(y1==y2){
			if(x1>x2) dierction=up;
			else dierction=down;
		}
		dis=(double)abs(h[x1]-h[x2])/2+(double)abs(w[y1]-w[y2])/2;
		mid_x=(double)(x1+x2)/2;
		mid_y=(double)(y1+y2)/2;
	}
	//在(x1,y1)与(x2,y2)两点中点，方向朝向direction，路段的半程长度为dis 
};//注意！x1,x2,y1,y2表示的是路口下标编号 
//订单信息-while(q--)实时处理 
int q;double ans;//订单数量q

//关于红绿灯系统：
#if 0/* 
g为南北向绿灯持续时间，r为东西向绿灯持续时间
变灯周期是(g+r)
==> 南北向绿灯时间区间 [n*(g+r),n*(g+r)+g )  左闭右开,n∈Z* 
	东西向绿灯时间区间 [n*(g+r)+g,(n+1)*(g+r) ) 左闭右开,n∈Z* 
==> ti时刻红绿灯状态：
	if(ti%(g+r)<g) 南北向绿灯，东西向红灯
	else if(ti%(g+r)>=g) 南北向红灯，东西向绿灯 
==>等待变灯时间:
	南北向绿灯时:dhd=g-ti%(g+r) 
	东西向绿灯时:dhd=g+r-ti%(g+r) */ 
#endif

int g[105][105],r[105][105];
inline bool pd(int ti,int idx,int idy){//true=南北向，false=东西向
	if(ti%(g[idx][idy]+r[idx][idy])<g[idx][idy])  return true;//南北向绿灯，东西向红灯
	else if(ti%(g[idx][idy]+r[idx][idy])>=g[idx][idy]) return false;//南北向红灯，东西向绿灯 
}
//？？我也不知道该怎么写的最短路 //100的数据量，果断暴力吧 
//g表示南北，r表示东西;;w是南北,h是东西;x的+-是南北移动,y的+-是东西移动 
bool vis[105][105][105][105];
double bestway(s1 s,s1 e,double total_ti){
	//s是当前位置，e是目标位置 
//	cout<<"When in"<<total_ti<<"s,Mark_point:("<<s.x1<<","<<s.y1<<")("<<s.x2<<","<<s.y2<<")\n";
//----------------------------------------------	
	//终点判定 if(s==e) return 0;
	if(s.x1==e.x1&&s.x2==e.x2&&s.y1==e.y1&&s.y2==e.y2){
//		cout<<"~~!!victory!!~~"<<"this mehod costs"<<total_ti<<endl<<endl;
		return 0;
	}
//----------------------------------------------
	//第一步，只能无脑往前开，先开到路口再说 
	vis[s.x1][s.y1][s.x2][s.y2]=true;
	double res=(1<<30);//从当前位置出发，到达终点的最短时间 
	double awsl=s.dis;
	//awsl表示从当前位置到达下一中点的时间 = 当前半条路+下一个半条路+等红灯的时间 
	//从当前位置到达nex的时间=half+awsl 
//------------------------------------------------
	//判断-在ans+total_ti时的 红绿灯情况 
	//此时到达(s.x2,s.y2)的十字路口 	 
	double dhd=0; s1 nex;//nex表示下个位置 ; dhd=如果要灯红灯，需要的等待时长
	int ti=floor(ans+total_ti+awsl);double sb=ans+total_ti+awsl-ti; 
	if(pd(ti,s.x2,s.y2)){//南北向绿灯 
		if(s.dierction==lleft||s.dierction==rright)//让东西向等待
			dhd= g[s.x2][s.y2]-ti%(g[s.x2][s.y2]+r[s.x2][s.y2]) ;
	}else{//东西向红灯 
		if(s.dierction==up||s.dierction==down)//让南北向等待 
			dhd=g[s.x2][s.y2]+r[s.x2][s.y2]-ti%(g[s.x2][s.y2]+r[s.x2][s.y2]) ;
	}dhd+=sb;
//	cout<<"等红灯:"<<dhd<<endl;
//-----------------------------------------------
	//合法情况下，有四种选,即四个方向 
	//剪枝+防止死循环：不绕圈就是省时间,不能重复到达同一pos 
	//无理由剪枝:不绕路 
	//to-lleft
	if(s.y2-1>=1&&s.y2>e.mid_y){
		nex=(s1){s.x2,s.y2,s.x2,s.y2-1,0};nex.dir();
		//如果没有兜圈 
		if(!vis[nex.x1][nex.y1][nex.x2][nex.y2]){
			awsl+=nex.dis;
			//判断转向并计算路口等待时间 
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl+=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl+=0;//右转或掉头 
			//到达下一个中点，继续深搜 
			res=min(res, awsl+bestway(nex,e,total_ti+awsl));//ti=awsl-s.dis=等灯和半条路 
			//回溯 
			awsl-=nex.dis;
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl-=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl-=0;//右转或掉头 
		}
	}
	//to-rright
	if(s.y2+1<=m&&s.y2<e.mid_y){
		nex=(s1){s.x2,s.y2,s.x2,s.y2+1,0};nex.dir();

		//如果没有兜圈 
		if(!vis[nex.x1][nex.y1][nex.x2][nex.y2]){
			awsl+=nex.dis;
			//判断转向并计算路口等待时间 
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl+=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl+=0;//右转或掉头 
			//到达下一个中点，继续深搜 
			res=min(res, awsl+bestway(nex,e,total_ti+awsl));//ti=awsl-s.dis=等灯和半条路 
			//回溯 
			awsl-=nex.dis;
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl-=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl-=0;//右转或掉头 
		}
	}
	//to-up
	if(s.x2-1>=1&&s.x2>e.mid_x){
		nex=(s1){s.x2,s.y2,s.x2-1,s.y2,0};nex.dir();
		//如果没有兜圈 
		if(!vis[nex.x1][nex.y1][nex.x2][nex.y2]){
			awsl+=nex.dis;
			//判断转向并计算路口等待时间 
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl+=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl+=0;//右转或掉头 
			//到达下一个中点，继续深搜 
			res=min(res, awsl+bestway(nex,e,total_ti+awsl));//ti=awsl-s.dis=等灯和半条路 
			//回溯 
			awsl-=nex.dis;
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl-=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl-=0;//右转或掉头 
		}
	}
	//to-down  
	if(s.x2+1<=n&&s.x2<e.mid_x){
		nex=(s1){s.x2,s.y2,s.x2+1,s.y2,0};nex.dir();
		//如果没有兜圈 
		if(!vis[nex.x1][nex.y1][nex.x2][nex.y2]){
			awsl+=nex.dis;
			//判断转向并计算路口等待时间 
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl+=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl+=0;//右转或掉头 
			//到达下一个中点，继续深搜 
			res=min(res, awsl+bestway(nex,e,total_ti+awsl));//ti=awsl-s.dis=等灯和半条路 
			//回溯
			awsl-=nex.dis;
			if(s.dierction==nex.dierction||(s.dierction+3)%4==nex.dierction) awsl-=dhd; //直走或左转
			if((s.dierction+2)%4==nex.dierction||(s.dierction+1)%4==nex.dierction)	awsl-=0;//右转或掉头 
		}
	}
	//回溯 
	vis[s.x1][s.y1][s.x2][s.y2]=false;//防止转圈
//	cout<<"回溯记录：When in"<<total_ti<<"s,Mark_point:("<<s.x1<<","<<s.y1<<")("<<s.x2<<","<<s.y2<<")\n";
//	cout<<"res="<<res<<endl;
	return res;
}


int main(){
	//一堆输入 
	n=read(),m=read();
	for(int i=2;i<=n;i++) h[i]=read();//东西 
	for(int i=2;i<=m;i++) w[i]=read();//南北 
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			g[i][j]=read();
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			r[i][j]=read();

	s1 pos=(s1){read(),read(),read(),read(),0};pos.dir();
	s1 home=pos;
	//开始跑单 
	q=read();double ls;
	while(q--){ 	s1 S,E;
		S=(s1){read(),read(),read(),read(),0};S.dir();
		E=(s1){read(),read(),read(),read(),0};E.dir();

		ls= bestway(pos,S,0);//从当前位置到接单位置 
		ans+=ls;
//		cout<<"本阶段:"<<ls<<endl<<"ans="<<ans<<endl<<endl;
		ls = bestway(S,E,0);//送单
		ans+=ls;
//		cout<<"本阶段:"<<ls<<endl<<"ans="<<ans<<endl<<endl<<"-------------"<<endl;
		
		pos=E;
	} 
//	cout<<"-----------------START-----------------------"<<endl;
	ls=bestway(pos,home,0);ans+=ls;//回家 
//	cout<<"本阶段:"<<ls<<endl<<"ans="<<ans<<endl<<endl;
	printf("%.1f",ans);
	return 0;
} 
/*

正解

第一遍做的时候读题模拟就差点累死，所以无脑dfs了
写完才发现，红绿灯时间直接在最短路的时候算在边权里就好了，于是有了下面这个spfa
建图+spfa最短路（AC）（100分)：//建图思路都在备注里

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
inline int read(){
	char ch=getchar();int sum=0;
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9')
		sum*=10,sum+=ch-'0',ch=getchar();
	return sum;
} 
//数据范围：n,m<=100; q<=30; h,w<=1e5; g,r<=1000; 
#include<cmath>
//建点 
int up=0,rright=1,down=2,lleft=3;
int h[105],w[105];int n,m;
const int N=100*100*2+5;//n*m的网格，正方向算两个点==>空间n*m*2; 
struct s1{
	int x1,y1,x2,y2;
	int dierction;//去往方向 
	double dis;//该路段的半程距离 
	void dir(){//判断dierction和dis 
		if(x1==x2){
			if(y1>y2) dierction=lleft;
			else dierction=rright;
		}
		if(y1==y2){
			if(x1>x2) dierction=up;
			else dierction=down;
		}
		dis=(double)abs(h[x1]-h[x2])/2+(double)abs(w[y1]-w[y2])/2;
	}
}pos[N];int tot;
int id[105][105][105][105];//查询对应点的id 
inline void add_pos(int x1,int y1,int x2,int y2){
	pos[++tot]=(s1){x1,y1,x2,y2,0,0};pos[tot].dir();
	id[x1][y1][x2][y2]=tot;
}

//建边
const int M=N*4;//每个点最多连出直走、左转、右转、调头四个边==>空间N*4 
bool ahead=true,turnleft=true,turnright=false,reback=false;//直走左转要等灯，右转掉头不需要 
struct s2{
	int to,nex;double va;
	bool turn;//记录转向 即是否需要等待红绿灯 
}edge[N*4];int head[N],ecnt;//不同时间点的红绿灯情况不同，因而边权在变化，不做定义 
inline void add(int x,int y,bool turn){//va=两边的半程的加和 
	edge[++ecnt]=(s2){y,head[x],pos[x].dis+pos[y].dis,turn};head[x]=ecnt;
}
bool zx(int x,int y){//判断从点x到点y的转向
	if(pos[x].dierction==pos[y].dierction||(pos[x].dierction+3)%4==pos[y].dierction) return true; //直走或左转
	if((pos[x].dierction+2)%4==pos[y].dierction||(pos[x].dierction+1)%4==pos[y].dierction) return false;//右转或掉头
}

//处理红绿灯系统：
#if 0/* 
g为南北向绿灯持续时间，r为东西向绿灯持续时间
变灯周期是(g+r)
==> 南北向绿灯时间区间 [n*(g+r),n*(g+r)+g )  左闭右开,n∈Z* 
	东西向绿灯时间区间 [n*(g+r)+g,(n+1)*(g+r) ) 左闭右开,n∈Z* 
==> ti时刻红绿灯状态：
	if(ti%(g+r)<g) 南北向绿灯，东西向红灯
	else if(ti%(g+r)>=g) 南北向红灯，东西向绿灯 
==>等待变灯时间:
	南北向绿灯时:dhd=g-ti%(g+r) 
	东西向绿灯时:dhd=g+r-ti%(g+r) */ 
#endif
#define start_time ans
int g[105][105],r[105][105];
double dis[N],ans;//dis[i]起点到i的最短时间，start_time从起点开始走的时刻，即ans
bool pd_light(int ti,int idx,int idy){//true=南北向，false=东西向
	if(ti%(g[idx][idy]+r[idx][idy])<g[idx][idy])  return true;//南北向绿灯，东西向红灯
	else if(ti%(g[idx][idy]+r[idx][idy])>=g[idx][idy]) return false;//南北向红灯，东西向绿灯 
}
double dhd(int x,int y){//从x点到y点，到十字路口的时刻是ti+sb时刻需要等红灯的时长 
	double dh=0; s1 nex;//nex表示下个位置 ; dhd=如果要灯红灯，需要的等待时长
	double ls=start_time+dis[x]+pos[x].dis;//当前时刻=到达点x的时刻+x到路口的时刻
	double sb=ls-floor(ls);
	int ti=floor(ls);
	//此时十字路口位置: (pos[x].x2,pos[x].y2 )
	if(pd_light(ti,pos[x].x2,pos[x].y2)){//南北向绿灯 
		if(pos[x].dierction==lleft||pos[x].dierction==rright)//让东西向等待
			dh= g[pos[x].x2][pos[x].y2]-ti%(g[pos[x].x2][pos[x].y2]+r[pos[x].x2][pos[x].y2]) ;
	}else{//东西向红灯 
		if(pos[x].dierction==up||pos[x].dierction==down)//让南北向等待 
			dh=g[pos[x].x2][pos[x].y2]+r[pos[x].x2][pos[x].y2]-ti%(g[pos[x].x2][pos[x].y2]+r[pos[x].x2][pos[x].y2]) ;
	} return dh+sb;//+sb的正确性：不可能两个方向都是红灯或都是绿灯 
}
//bfs最短路
#include<queue>
bool vis[N];//dis[to]=min(dis[to],dis[pos]+edge[i].va+dhd(pos,to))
inline double bfs(int S,int T){
	for(int i=0;i<=tot;i++) dis[i]=(1<<30);
	memset(vis,0,sizeof(vis));
	queue<int>q;q.push(S);vis[S]=true;dis[S]=0;
	while(!q.empty()){
		int pos=q.front();q.pop();vis[pos]=false;
		//cout<<S<<":"<<pos<<endl;
		for(int i=head[pos];i;i=edge[i].nex){
			int to=edge[i].to;double va;
			if(zx(pos,to)) va=edge[i].va+dhd(pos,to);//直走、左转等红灯 
			else va=edge[i].va;//右转，调头直接走
			
			if(dis[to]>dis[pos]+va){
				dis[to]=dis[pos]+va;
				if(!vis[to]){
					q.push(to);
					vis[to]=true;
				}
			} 
		}
	}
	return dis[T];
} 


int home;
int main(){
	//读入 
	n=read(),m=read();
	for(int i=2;i<=n;i++) h[i]=read();//东西 距离 
	for(int i=2;i<=m;i++) w[i]=read();//南北 距离
	//建点 
	for(int x1=1;x1<=n;x1++)
		for(int y1=1;y1<=m;y1++){
			if(x1+1<=n) add_pos(x1,y1,x1+1,y1);//down
			if(x1-1>=1) add_pos(x1,y1,x1-1,y1);//up
			if(y1+1<=m) add_pos(x1,y1,x1,y1+1);//rright
			if(y1-1>=1) add_pos(x1,y1,x1,y1-1);//lleft
		}
	//建边
	for(int i=1;i<=tot;i++){
		int x1=pos[i].x1,x2=pos[i].x2,y1=pos[i].y1,y2=pos[i].y2;int to; 
		to=id[x2][y2][x2+1][y2]; if(to) add(i,to,zx(i,to));
		to=id[x2][y2][x2][y2+1]; if(to) add(i,to,zx(i,to));
		to=id[x2][y2][x2-1][y2]; if(to) add(i,to,zx(i,to));
		to=id[x2][y2][x2][y2-1]; if(to) add(i,to,zx(i,to));
	} 
	//红绿灯信息 
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			g[i][j]=read();
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			r[i][j]=read();
	//home
	home=id[read()][read()][read()][read()];
	//跑单
	int q=read();int pp=home;double ls;//pp为当前位置 ls调试用的，可忽略 
	while(q--){
		int s=id[read()][read()][read()][read()];//接单起点 
		int e=id[read()][read()][read()][read()];//送单终点 
		ls=bfs(pp,s);ans+=ls;//当前位置到接单位置
//		cout<<"本阶段:"<<ls<<endl<<"ans="<<ans<<endl<<endl;
		ls=bfs(s,e); ans+=ls;
//		cout<<"本阶段:"<<ls<<endl<<"ans="<<ans<<endl<<endl;
		pp=e;
//		cout<<"还剩"<<q<<"单:"<<ans<<endl;
	}
	ls=bfs(pp,home);ans+=ls;//回家 
//	cout<<"本阶段:"<<ls<<endl<<"ans="<<ans<<endl<<endl;
	printf("%.1f",ans);		return 0;					
}

贪心：

根据生活常识朴素地认为，如果重复走一个点，那一定是绕路，没有意义。
所以推证 到达任意地点的最短路有且只有一个。根据BFS逻辑更新即可。

GoesM
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第37期：蓝桥杯-第九届蓝桥杯省赛A组题解
qq_57351574的博客
02-21 582
J 结账问题（25） 贪心：2018年第九届蓝桥杯C/C++A组省赛（最后一题） - MXR_alone - 博客园 #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #define ll long long #define num ch-'0' #define ld long double #def
蓝桥杯自我刷题11
thingwillbeOK的博客
03-17 258
题意翻译 19世纪的德国数学家赫尔曼·闵可夫斯基(Hermann Minkowski)研究了一种名为出租车几何学的非欧几何。 在出租车几何里T_1(x_1,y_1)T1​(x1​,y1​)T_2(x_2,y_2)T2​(x2​,y2​)两点之间的距离被定义为dis(T_1,T_2)=|x_1-x_2|+|y_1-y_2|dis(T1​,T2​)=∣x1​−x2​∣+∣y1​−y2​∣(曼哈顿距离)。 其他定义均与欧几里得几何相同。 例如圆的定义：在同一平面内，到定点(圆心)的距离等于定长(半径)的点的集.
2020第十届蓝桥杯大赛决赛真题.rar
11-09
第十届蓝桥杯国赛真题，JAVA和c语言。主页有①蓝桥杯VIP题目提交渠道，超详细截图教程。 ②蓝桥杯题库赛题Python代码解析 ③python版的数据结构和算法，并且配备各阶段的例题，适合新手入门看。 欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞，有问题 或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~ 另外，刚刚上手Python的同学可以参考菜鸟教程学习： https://www.runoob.com/python3.html
第十一届蓝桥杯c++B组国赛
pingfanblog
11-15 3789
省赛传送门：第十一届蓝桥杯省赛第二场 昨天在本校机房考的c++B组国赛，第十一届蓝桥杯因为疫情，原本在大二下学期考的，结果推迟到了大三上，想白嫖北京旅游也是泡汤了(hh，学校挺好，都报销了)。蒻蒻第一次参加，水了个国三。大概二个填空，一道大题，在顺便骗点分吧(hh)，国三中。同学比我多做了个大题（游园安排）国三上。害，菜是本质。 不知道是第一次参加的缘故还是紧张，赛后又去看了下题目。填空最后一道考试的时候没读懂题意，考完读懂了，就一个简单的搜索。约数那题也是无语，不知道那个定理，知道了就很好写，可惜考场
蓝桥杯【第十一届】【决赛】F皮亚诺曲线距离 + G出租车
ZJ_JS_ZXB的博客
02-19 1462
题目地址 官网地址 F皮亚诺曲线距离 找规律的题目，应该有各种各样的方法来做 （代码写完才发现我的x,y和题目是反过来的qwq， 不过都一样） （顺带吐槽一下，为啥不用写高精度就能过，题目里只是要求答案小于101810^{18}1018，x1,x2,y1,y2x_1, x_2, y_1, y_2x1​,x2​,y1​,y2​只要小于31003^{100}3100就行了啊）不过不用写高精度我也就不写了 显然我们可以分别求两个点到原点的距离，然后相减即可。 我们发现，对于n阶皮亚诺曲线，它是由9个n-1阶皮亚诺
蓝桥杯官网 试题 PREV-236 历届真题 出租车【第十一届】【决赛】【研究生组】【C++】一种解法
红目香薰
05-30 486
为帮助大家能在6月18日的比赛中有一个更好的成绩，我会将蓝桥杯官网上的历届决赛题目的四类语言题解都发出来。希望能对大家的成绩有所帮助。 今年的最大目标就是能为【一亿技术人】创造更高的价值。 资源限制 内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s C++ #include<cstdio> #include<cstring> #include<algorithm> const i...
【B类比赛】 第十一届蓝桥杯 省国赛经历
热门推荐
LH_991215的博客
04-17 1万+
第十一届蓝桥杯国一记录
2020第十一届蓝桥杯国赛个人题解+源代码
Z28_99的博客
11-15 6609
先存个样~~之后补全 个人解法，可能不是最佳，欢迎指错 A：美丽的 2 思路：直接1-2020枚举判断 int main(){ int tot=0; for(int i=1;i<=2020;i++){ int k=i; while(k){ int g=k%10; k/=10; if(g==2){tot++;break;} } } cout<&
2020第十一届蓝桥杯大赛软件类国赛题目 C/C++ B 组
weixin_43985130的博客
11-14 6595
2020年 第十一届 蓝桥杯 软件类Java B组 决赛 （国赛） 题目 + 个人答案试题 A: 美丽的 2试题 B: 扩散试题 C: 阶乘约数试题 D: 本质上升序列试题 E: 玩具蛇试题 F: 皮亚诺曲线距离试题 G: 游园安排试题 H: 答疑试题 I: 出租车试题 J: 质数行者 试题 A: 美丽的 2 本题总分：5 分 【问题描述】 小蓝特别喜欢 2，今年是公元 2020 年，他特别高兴。 他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中包含数字 2？ 真没想到第一题能这
第十一届蓝桥杯大赛软件类决赛 C++ B组 题解
Designer 小郑的技术博客
11-14 9770
声明：本人水平有限，只是个人的见解，如果有更好的答案，欢迎评论区或者私信我，我会注明您的题解来源，谢谢支持！ 本文是2020年11月14日的蓝桥杯全国总决赛 软件类 C B组题解 本文原创首发CSDN，本文链接https://blog.csdn.net/qq_41464123/article/details/109695384，作者博客https://zwz99.blog.csdn.net/，转载请带上本链接，谢谢配合。 试题 A: 美丽的 2 本题总分：5 分 我的答案：563，水题暴...
SPFA+Dijkstra+Floyd Java模板
01-20
SPFA import java.util.Arrays; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class SPFA { static SE[] e = new SE[9999]; static int[] dis = new int[9999]; ...
蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf
最新发布
02-18
蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf
从一道题目比较dijkstra和spfa算法.doc
05-06
从一道题目比较dijkstra和spfa算法.doc
SPFA算法模版+邻接表实现.docx
05-06
SPFA算法模版+邻接表实现.docx
c++ SPFA算法
03-05
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。
第14届蓝桥杯省赛真题剖析-2023年5月7日Scratch编程中级组
超平的编程课
05-30 6296
第14届蓝桥杯Scratch省赛真题，这是2023年5月7日举办的省赛中级组试题，比赛仍然采取线上形式。试题包括两种题型，分别是选择题和编程创作题，其中选择题5道，都是和Scratch编程知识相关的题目，编程创作题有6道。分别是魔术表演、小猫踩球、放大镜、小狗避障、智能计价器和消除字母。
2020年第十一届蓝桥杯大赛软件类决赛(国赛) C/C++ 大学A组【题面】
nefu_ljw的博客
11-14 4693
记录一下国赛的题面，真的和省赛完全不是一个难度的。这次估计国三都混不到，还是太菜了QAQ，之后如果能补题就补吧。 题面的pdf文件我也上传到CSDN下载区了，内容和本篇文章一致（题面真长，我复制到markdown修改格式都搞了半天） 文章目录试题 A: 合数个数（5 分）试题 B: 含 2 天数（5 分）试题 C: 本质上升序列（10 分）试题 D: 咫尺天涯（10 分）试题 E: 玩具蛇（15 分）试题 F: 皮亚诺曲线距离（15 分）试题 G: 出租车（20 分）试题 H: 答疑（20 分）试题 I:
重复字符串【第十一届】【决赛】【研究生组】
qq_47991812的博客
11-18 248
如有abc bba adc 则在第一轮中f['a'] = 2,f['b'] = 1,第二轮中f['b'] = 2,f['d'] = 1,第三轮中f['c'] = 2,f['a'] = 1。#如有abc bba adc 则在第一轮中f['a'] = 2,f['b'] = 1,第二轮中f['b'] = 2,f['d'] = 1,第三轮。#把字符串分成k个长为lenth/k的串，并保存每个串的起始下标，如样例分成2个长为3的串。#建立一个标志数组初始为0，统计每个字串包含的字符种类，以及各个种类的数量，
Dijkstra算法（蓝桥杯省赛真题）
Stephen_Curry___的博客
04-08 635
⭐路径 思路：本题就是考察最短路径的算法，用Dijskra算法即可求解。 #include<bits/stdc++.h> using namespace std; typedef long long ll; ll e[2050][2050],dist[2050]; bool st[2050]; ll gcd(ll a,ll b)//求公约数 { return a%b==0?b:gcd(b,a%b); } ll lcm(ll a,ll b)//求最小公倍数 { return a*b/(g
SPFA算法 求解自行车慢速比赛问题
04-27
SPFA算法是一种单源最短路径算法，可以用来解决自行车慢速比赛问题。 在这个问题中，我们可以将自行车手看作图中的顶点，道路看作边。每条边有一个权值，表示骑行这条道路需要的时间。我们需要找到从起点到终点的最短路径，即骑行时间最短的路径。 使用SPFA算法可以很方便地解决这个问题。首先初始化起点的距离为0，其他顶点的距离为无穷大。然后将起点加入一个队列中。每次从队列中取出一个顶点，并遍历该顶点的所有邻居。对于每个邻居，如果通过当前顶点能够获得更短的路径，则更新邻居的距离，并将邻居加入队列中。重复这个过程，直到队列为空。 最终，终点的距离就是从起点到终点的最短路径。如果终点的距离为无穷大，则表示不存在从起点到终点的路径。 需要注意的是，SPFA算法可能会陷入负环的死循环中。因此，在实际使用中需要进行一些优化，比如限制每个顶点的入队次数或者使用Bellman-Ford算法进行检测。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GoesM

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值