【PAT】Dijkstra+最短路径种数（★）+输出路径+卡内存

最新推荐文章于 2021-09-09 17:10:56 发布
最新推荐文章于 2021-09-09 17:10:56 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： ＰＡＴ机试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cacyth/article/details/52097208
版权

https://www.patest.cn/contests/pat-a-practise/1087

在求最短路径种数的时候，是这样写的：

#include<bits/stdc++.h> 
using namespace std;  
int n,m,ed,a;
string st,z,y;
map<string,int> r;
struct node{
	string a;
	int b;	
}x[205];
int w[205][205];
int path[205];
int num[205];
int happy[205];
int cost[205];
int main(){
	cin>>n>>m>>st;
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			w[i][j]=100000000;
		}
	}
	x[0].a=st;
	r[st]=0;
	for(int i=1;i<n;++i){
		cin>>x[i].a>>x[i].b;
		if(x[i].a=="ROM")
			ed=i;
		r[x[i].a]=i;
	}
	while(m--){
		cin>>y>>z>>a;
		w[r[y]][r[z]]=a;
		w[r[z]][r[y]]=a;
	}
	for(int i=0;i<n;++i){
		cost[i]=100000000;
	}
	priority_queue<int> q;
	q.push(0);
	cost[0]=0;
	int costs=100000000,happys=-1,nums=100000000,sum=-1,p;
	while(!q.empty()){
		int fr=q.top();
		q.pop();
		if(fr==ed){
			if(cost[fr]<costs||
			(cost[fr]==costs&&happy[fr]>happys)||
			(cost[fr]==costs&&happy[fr]==happys&&num[fr]<nums)){
				costs=cost[fr];
				happys=happy[fr];
				nums=num[fr];
				p=fr;
			}
			if(cost[fr]<costs)
				sum=1;
			else if(cost[fr]==costs)
				sum++;
			continue;
		}
		for(int i=0;i<n;++i){
			if(cost[fr]+w[fr][i]<=cost[i]){
				cost[i]=cost[fr]+w[fr][i];
				if(happy[fr]+x[i].b>happy[i]||
				(happy[fr]+x[i].b==happy[i]&&num[fr]+1<num[i])){
					happy[i]=happy[fr]+x[i].b;
					num[i]=num[fr]+1;
					path[i]=fr;
				}
				q.push(i);
			}
		}
	}
	cout<<sum<<" "<<costs<<" "<<happys<<" "<<happys/nums<<endl;
	stack<int> st;
	st.push(ed);
	while(ed!=0){
		ed=path[ed];
		st.push(ed);
	}
	while(!st.empty()){
		cout<<x[st.top()].a;
		st.pop();
		if(st.empty())
			cout<<endl;
		else
			cout<<"->";
	}
}
然后就因为这个【 最短路径种数】和【内存超限】报错了。

修改之后是这样写的：

#include<bits/stdc++.h> 
using namespace std;  
int n,m,ed,a;
string st,z,y;
map<string,int> r;
struct node{
	string a;
	int b;	
}x[205];
int w[205][205];
int path[205];
int num[205];
int happy[205];
int cost[205];
int over[205];
int main(){
	cin>>n>>m>>st;
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			w[i][j]=100000000;
		}
	}
	x[0].a=st;
	r[st]=0;
	for(int i=1;i<n;++i){
		cin>>x[i].a>>x[i].b;
		if(x[i].a=="ROM")
			ed=i;
		r[x[i].a]=i;
	}
	while(m--){
		cin>>y>>z>>a;
		w[r[y]][r[z]]=a;
		w[r[z]][r[y]]=a;
	}
	for(int i=0;i<n;++i){
		cost[i]=100000000;
	}
	priority_queue<int> q;
	q.push(0);
	cost[0]=0;
	over[0]=1;
	int costs=100000000,happys=-1,nums=100000000,sum=-1,p;
	while(!q.empty()){
		int fr=q.top();
		q.pop();
		if(fr==ed){
			if(cost[fr]<costs||
			(cost[fr]==costs&&happy[fr]>happys)||
			(cost[fr]==costs&&happy[fr]==happys&&num[fr]<nums)){
				costs=cost[fr];
				happys=happy[fr];
				nums=num[fr];
				p=fr;
			}
			if(cost[fr]<costs)
				sum=1;
			else if(cost[fr]==costs)
				sum++;
			continue;
		}
		for(int i=0;i<n;++i){
			if(cost[fr]+w[fr][i]<=cost[i]){
				if(happy[fr]+x[i].b>happy[i]||
				(happy[fr]+x[i].b==happy[i]&&num[fr]+1<num[i])){
					happy[i]=happy[fr]+x[i].b;
					num[i]=num[fr]+1;
					path[i]=fr;
				}
				if(cost[i]==cost[fr]+w[fr][i]){
					over[i]+=over[fr];
				}
				else{
					q.push(i);
					over[i]=over[fr];
					cost[i]=cost[fr]+w[fr][i];
				}
			}
		}
	}
	cout<<over[ed]<<" "<<costs<<" "<<happys<<" "<<happys/nums<<endl;
	stack<int> st;
	st.push(ed);
	while(ed!=0){
		ed=path[ed];
		st.push(ed);
	}
	while(!st.empty()){
		cout<<x[st.top()].a;
		st.pop();
		if(st.empty())
			cout<<endl;
		else
			cout<<"->";
	}
}
一开始以为【内存超限】是因为我没有把费用相同的路径合并计算（即第一个代码），但其实不是这个原因，而是我的Dijkstra是优先队列nlogn版的……改成了n2的版本就过了。 

#include<bits/stdc++.h> 
using namespace std;  
int n,m,ed,a;
string st,z,y;
map<string,int> r;
struct node{
	string a;
	int b;	
}x[205];
int w[205][205];
int path[205];
int num[205];
int happy[205];
int cost[205];
int over[205];
int main(){
	cin>>n>>m>>st;
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			w[i][j]=100000000;
		}
	}
	x[0].a=st;
	r[st]=0;
	for(int i=1;i<n;++i){
		cin>>x[i].a>>x[i].b;
		if(x[i].a=="ROM")
			ed=i;
		r[x[i].a]=i;
	}
	while(m--){
		cin>>y>>z>>a;
		w[r[y]][r[z]]=a;
		w[r[z]][r[y]]=a;
	}
	for(int i=0;i<n;++i){
		cost[i]=100000000;
	}
	cost[0]=0;
	over[0]=1;
	int vis[205]={0};
	int costs=100000000,happys=-1,nums=100000000,p;
	for(int nn=0;nn<n;++nn){
		int fr;
		int minn=100000000;
		for(int i=0;i<n;++i){
			if(vis[i]==1) continue; //这步千万别忘啊！！
			if(cost[i]<minn){
				minn=cost[i];
				fr=i;
			}
		}
		vis[fr]=1; //这步千万别忘啊！！
		if(fr==ed){
			if(cost[fr]<costs||
			(cost[fr]==costs&&happy[fr]>happys)||
			(cost[fr]==costs&&happy[fr]==happys&&num[fr]<nums)){
				costs=cost[fr];
				happys=happy[fr];
				nums=num[fr];
				p=fr;
			}
			continue;
		}
		for(int i=0;i<n;++i){
			if(vis[i]==1) continue; //这步千万别忘啊！！
			if(cost[fr]+w[fr][i]<=cost[i]){
				if(cost[fr]+w[fr][i]<cost[i]||
				(cost[fr]+w[fr][i]==cost[i]&&happy[fr]+x[i].b>happy[i])||
				(cost[fr]+w[fr][i]==cost[i]&&happy[fr]+x[i].b==happy[i]&&num[fr]+1<num[i])){
					happy[i]=happy[fr]+x[i].b;
					num[i]=num[fr]+1;
					path[i]=fr;
				}
				if(cost[i]==cost[fr]+w[fr][i]){
					over[i]+=over[fr];
				}
				else{
					over[i]=over[fr];
					cost[i]=cost[fr]+w[fr][i];
				}
			}
		}
	}
	cout<<over[ed]<<" "<<costs<<" "<<happys<<" "<<happys/nums<<endl;
	stack<int> st;
	st.push(ed);
	while(ed!=0){
		ed=path[ed];
		st.push(ed);
	}
	while(!st.empty()){
		cout<<x[st.top()].a;
		st.pop();
		if(st.empty())
			cout<<endl;
		else
			cout<<"->";
	}
}


然后再仔细一看——哎呀原来内存超限的根本原因是优先队列根本就忘了用到“优先”了！(￣_￣╬
于是，最完美的版本如下： 

#include<bits/stdc++.h> 
using namespace std;  
int n,m,ed,a;
string st,z,y;
map<string,int> r;
struct node{
	string a;
	int b;	
}x[205];
int w[205][205];
int path[205];
int num[205];
int happy[205];
int cost[205];
int over[205];
struct cmp{
	bool operator()(const int &t1,const int &t2){  
        return cost[t1]>cost[t2];  //从小到小=大，与数组规则相反   
   }  
}; 
int main(){
	cin>>n>>m>>st;
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			w[i][j]=100000000;
		}
	}
	x[0].a=st;
	r[st]=0;
	for(int i=1;i<n;++i){
		cin>>x[i].a>>x[i].b;
		if(x[i].a=="ROM")
			ed=i;
		r[x[i].a]=i;
	}
	while(m--){
		cin>>y>>z>>a;
		w[r[y]][r[z]]=a;
		w[r[z]][r[y]]=a;
	}
	for(int i=0;i<n;++i){
		cost[i]=100000000;
	}
	priority_queue<int,vector<int>,cmp> q;
	q.push(0);
	cost[0]=0;
	over[0]=1;
	int vis[205]={0};  //这步千万别忘啊！！ 
	int costs=100000000,happys=-1,nums=100000000,p;
	while(!q.empty()){
	    int fr=q.top();
	    q.pop();
	    if(vis[fr]==1) continue;  //这步千万别忘啊！！ 
	    vis[fr]=1;                //这步千万别忘啊！！ 
		if(fr==ed){
			if(cost[fr]<costs||
			(cost[fr]==costs&&happy[fr]>happys)||
			(cost[fr]==costs&&happy[fr]==happys&&num[fr]<nums)){
				costs=cost[fr];
				happys=happy[fr];
				nums=num[fr];
				p=fr;
			}
			continue;
		}
		for(int i=0;i<n;++i){
			if(vis[i]==1) continue; //这步千万别忘啊！！ 
			if(cost[fr]+w[fr][i]<=cost[i]){
				if(cost[fr]+w[fr][i]<cost[i]||
				(cost[fr]+w[fr][i]==cost[i]&&happy[fr]+x[i].b>happy[i])||
				(cost[fr]+w[fr][i]==cost[i]&&happy[fr]+x[i].b==happy[i]&&num[fr]+1<num[i])){
					happy[i]=happy[fr]+x[i].b;
					num[i]=num[fr]+1;
					path[i]=fr;
				}
				if(cost[i]==cost[fr]+w[fr][i]){
					over[i]+=over[fr];
				}
				else{
					q.push(i);
					over[i]=over[fr];
					cost[i]=cost[fr]+w[fr][i];
				}
			}
		}
	}
	cout<<over[ed]<<" "<<costs<<" "<<happys<<" "<<happys/nums<<endl;
	stack<int> st;
	st.push(ed);
	while(ed!=0){
		ed=path[ed];
		st.push(ed);
	}
	while(!st.empty()){
		cout<<x[st.top()].a;
		st.pop();
		if(st.empty())
			cout<<endl;
		else
			cout<<"->";
	}
}
总结一下：考PAT还是别写什么复杂的优先队列还是前向星了，节省时间增加正确率才是王道！

另外，PAT的最短路做来做去感觉好像都差不多。比如：

https://www.patest.cn/contests/pat-a-practise/1111

#include<bits/stdc++.h> 
using namespace std;  
struct node{
	int a,b;
}x[505][505];
int dis[505];
int spd[505];
int vis[505];
int path[505];
int path2[505];
int n,m,a,b,c,d,e,st,ed;
int main(){
	cin>>n>>m; 
	for(int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			x[i][j].a=x[i][j].b=100000000;
		}
	}
	while(m--){
		cin>>a>>b>>c>>d>>e;
		if(c==1)
			x[a][b]={d,e};
		else{
			x[a][b]={d,e};
			x[b][a]={d,e};
		}
	}
	cin>>st>>ed;
	int tmp=ed;
	for(int i=0;i<n;++i){
		dis[i]=100000000;
		spd[i]=100000000;
	}
	dis[st]=0;spd[st]=0;
	for(int nn=0;nn<n;++nn){
		int minn=100000000,minn2=100000000,p=-1;
		for(int i=0;i<n;++i){
			if(((dis[i]<minn)||
			(dis[i]==minn&&spd[i]<minn2))&&vis[i]==0){
				minn=dis[i];
				minn2=spd[i];
				p=i; 
			} 
		}
		vis[p]=1;
		if(p==ed)
			break;
		for(int i=0;i<n;++i){
			if(vis[i]==1) continue;
			if(dis[p]+x[p][i].a<dis[i]||
			(dis[p]+x[p][i].a==dis[i]&&spd[p]+x[p][i].b<spd[i])){
				dis[i]=dis[p]+x[p][i].a;
				spd[i]=spd[p]+x[p][i].b;
				path[i]=p;
			}
		}
	}
	int ans=dis[ed];
	for(int i=0;i<n;++i){
		dis[i]=100000000;
		spd[i]=100000000;
	}
	ed=tmp;
	dis[st]=0;spd[st]=0;
	memset(vis,0,sizeof(vis));
	for(int nn=0;nn<n;++nn){
		int minn=100000000,minn2=100000000,p=-1;
		for(int i=0;i<n;++i){
			if(((spd[i]<minn)||
			(spd[i]==minn&&dis[i]<minn2))&&vis[i]==0){
				minn=spd[i];
				minn2=dis[i];
				p=i; 
			} 
		}
		vis[p]=1;
		if(p==ed)
			break;
		for(int i=0;i<n;++i){
			if(vis[i]==1) continue;
			if(spd[p]+x[p][i].b<spd[i]||
			(spd[p]+x[p][i].b==spd[i]&&dis[p]+1<dis[i])){
				spd[i]=spd[p]+x[p][i].b;
				dis[i]=dis[p]+1;
				path2[i]=p;
			}
		}
	}
	int u=0;
	while(ed!=st){
		if(path[ed]!=path2[ed]){
			u=1;
			break;
		}
		ed=path[ed];
	}
	ed=tmp;
	stack<int> stk;
	if(u==0){
		cout<<"Distance = "<<ans<<"; Time = "<<spd[ed]<<": ";
		stk.push(ed);
		while(ed!=st){
			ed=path[ed];
			stk.push(ed);
		}
		while(!stk.empty()){
			cout<<stk.top();
			stk.pop();
			if(!stk.empty())
				cout<<" -> ";
			else
				cout<<endl;
		}
		return 0;
	}
	cout<<"Distance = "<<ans<<": ";
	stk.push(ed);
	while(ed!=st){
		ed=path[ed];
		stk.push(ed);
	}
	while(!stk.empty()){
		cout<<stk.top();
		stk.pop();
		if(!stk.empty())
			cout<<" -> ";
		else
			cout<<endl;
	}
	ed=tmp;
	cout<<"Time = "<<spd[ed]<<": ";
	stk.push(ed);
	while(ed!=st){
		ed=path2[ed];
		stk.push(ed);
	}
	while(!stk.empty()){
		cout<<stk.top();
		stk.pop();
		if(!stk.empty())
			cout<<" -> ";
		else
			cout<<endl;
	}
}
再比如：

https://www.patest.cn/contests/gplt/L2-001

#include<bits/stdc++.h>
#define ll long long
using namespace std; //
struct EDGE{
    int u,v,w,next;
}edge[500*500*2+5];
int head[500*500+5],pp;
void init(){
	pp=0;
	memset(head,0,sizeof(head));
}
void add(int u,int v,int w){
    edge[++pp]=(EDGE){u,v,w,head[u]};
    head[u]=pp;
}
int n,m,a,b,c,d,e;
int x[505];
int vis[505];
int dis[505];
int cost[505];
int path[505];
int times[505];
struct cmp{  
   bool operator()(const int &t1,const int &t2){ 
   		if(dis[t1]!=dis[t2]) 
        	return dis[t1]>dis[t2];
        return cost[t1]<cost[t2];
   }  
};  
int main(){
	cin>>n>>m>>a>>b;
	init();
	for(int i=0;i<n;++i)
		cin>>x[i];
	while(m--){
		cin>>c>>d>>e;
		add(c,d,e);
		add(d,c,e);
	}
	for(int i=0;i<n;++i)
		dis[i]=100000000;
	priority_queue<int,vector<int>,cmp> q;
	q.push(a);
	dis[a]=0;
	cost[a]=x[a];
	times[a]=1;
	while(!q.empty()){
		int u=q.top();
		q.pop();
		if(vis[u]==1) continue;
		vis[u]=1;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v;
			int w=edge[i].w;
			if(vis[v]==1) continue;
			if(dis[u]+w<dis[v]) times[v]=times[u];
			else if(dis[u]+w==dis[v]) times[v]+=times[u]; 
			if(dis[u]+w<dis[v]){
				dis[v]=dis[u]+w;
				cost[v]=cost[u]+x[v];
				q.push(v);
				path[v]=u;
			}
			else if(dis[u]+w==dis[v]&&cost[u]+x[v]>cost[v]){
				cost[v]=cost[u]+x[v];
				q.push(v);
				path[v]=u;
			}
		}
	}
	cout<<times[b]<<" "<<cost[b]<<endl;
	stack<int> st;
	int tmp=b;
	while(path[b]!=a){
		st.push(path[b]);
		b=path[b];
	}
	cout<<a;
	while(!st.empty()){
		cout<<" "<<st.top();
		st.pop();
	}
	if(b!=a)
		cout<<" "<<tmp;
	cout<<endl;
}
如果九月份再出这种类型的压轴题就完全可以pass了……

ccyy-
关注
专栏目录
PAT、蓝桥杯 最短路径总结
刷子的博客
08-24 680
文章目录PAT浙江大学-数据结构-2019夏 **07-图6** **旅游规划** (25分) [Dijikstra算法]浙江大学-数据结构-2019夏 08-图7 公路村村通 (30分) [Prim算法]A**1003** **Emergency** **(25分)**A1018 Public Bike Management (30分)A1030 Travel Plan (30分)A1087 All Roads Lead to Rome (30分) [Dijkstra算法 + DFS，最短路径]A1111
【PAT】Dijkstra
Nigel_Zhou的博客
02-23 343
Dijkstra汇总概述标准套路变化 概述 Dijkstra算法主要用于解决单源最短路径问题。在题目中，一般除了求最短路径还会附加其他条件加以筛选，求得唯一路径。 标准套路 st=起点，en=终点，D[ ]=到各点的最短路径，dis[ ][ ]=各点之间的路径长度（注意，a到b和b到a都要存储），visit[ ]=访问控制，pre[ ]=各点的前驱结点 首先要将不能用0初始化的各对象用fill函数...
1072. Gas Station (30)【最短路dijkstra】——PAT (Advanced Level) Practise
01-02 1618
题目信息1072. Gas Station (30)时间限制200 ms 内存限制65536 kB 代码长度限制16000 BA gas station has to be built at such a location that the minimum distance between the station and any of the residential housing is as
PAT——最短路径
Star's blogs
08-27 256
1018 Public Bike Management (30 分) （Dijkstra+dfs） There is a public bike service in Hangzhou City which provides great convenience to the tourists from all over the world. One may rent a bike a...
PAT甲级Dijkstra总结
qq_37370420的博客
11-15 511
目前PAT甲级中涉及Dijkstra的题目有如下几题：                                           1003 Emergency (25)                                 1018 Public Bike Management (30)                                         ...
PAT：图的最短路径
jinzhao1993的博客
04-16 630
1003 求无向图中最短路径的条数和最大权重和思路：在dj算法的基础上，还要增加两个数组pathNum[]和sum[]。当更新最短路径时，if(dis[j]>(dis[u]+e[u][j])){ dis[j]=(dis[u]+e[u][j]);//正常更新最短路径 pathNum[j]=pathNum[u];//pathNum更新 sum[j]=sum[u]+num[j];/
pat L2-1. 紧急救援——dijkstra
几人憔悴几人泪
05-01 3481
L2-1. 紧急救援 时间限制 200 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 陈越 作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数
pat最短路径-dj
qq_43543296的博客
03-28 347
pat最短路径最短路径分析难度：P1003P1018P1030P1072小结 最短路径 1003. Emergency (25)-PAT甲级真题（Dijkstra算法） 1018. Public Bike Management (30)-PAT甲级真题（Dijkstra + DFS） 1030. Travel Plan (30)-PAT甲级真题（Dijkstra + DFS，输出路径，边权） 1072. Gas Station (30)-PAT甲级真题（Dijkstra） 1087. All Roads L
PAT刷题——图的最短路径(Dijstra)
sherpahu的博客
05-09 136
PAT1003 Dijstra #include <bits/stdc++.h> using namespace std; const int MAXN=510; int n,m,st,ed,G[MAXN][MAXN],weight[MAXN]; int d[MAXN],w[MAXN],num[MAXN]; bool vis[MAXN]; const int INF=1000000000; void dijstra(int s){ fill(d,d+MAXN,INF); memset(nu
PAT-关于最短路径-Dijkstra+(DFS)
valcanoshan的博客
07-18 412
求单源或全局最短路径（无负边）-> 用Dijkstra： #include <iostream> const int inf = 999999999; cosnt int maxn = 500; int main(){ int e[maxn][maxn],dis[maxn]; fill(e[0],e[0]+maxn*maxn,inf); fill(...
【ACM】- PAT. A1030 Travel Plan 【图 - 最短路径】
三个石头
08-25 340
题目链接 题目分析： 结点编号 0 ~ N-1 题目满足最优子结构，可以直接得出最佳最短路径，也可以先保存所有最短路径，最后统一筛选！ 思路一： 直接在遍历Dijkstra()过程中选出最佳最短路径 /********************************** *@ID: 3stone *@ACM: PAT.A1030 Travle Plan *@Time: 18/8...
最短路径 pat 1003
BuGengFeng的博客
09-03 181
#include <iostream> //1003 using namespace std; const int N = 510; const int inf = 1e9; int n,m,st,ed; int vis[N]={0}; int G[N][N] = {0}; int w[N],weight[N]; int d[N]; int num[N]; void dij(int ...
PAT 备考——图论算法（二）最短路径
狄利克雷的博客
11-28 835
最短路径算法是PAT甲级考试常考算法，具体说来，最短路径包括Dijkstra算法、Floyd算法，其余的Bellman-Ford和SPFA基本不会考（参《算法笔记》胡凡，曾磊著） 目录 一、最短路径基本概念与问题分类 1.基本概念 2.问题分类 二、Dijkstra算法 1.伪代码 2.示意图 3.参考代码 4.升级 5.Dijkstra+DFS   一、最短路径基本概...
PAT dijkstra模板
NoobPlayer_llke的博客
05-05 157
常规版，大多数情况下用这个即可 #include<bits/stdc++.h> #define rep(i,a,n) for(int i=a;i<n;i++) #define INF 0x3f3f3f3f using namespace std; const int N=2333; int n,m,k; int g[N][N]; int dist[N],vis[N]; in...
PAT 1087 最短路径
qq_44910084的博客
05-11 118
题目 Indeed there are many different tourist routes from our city to Rome. You are supposed to find your clients the route with the least cost while gaining the most happiness. Input Specification: Each input file contains one test case. For each case, the f
PAT备考之 最短路径 专题
maxleo928的博客
09-09 196
PAT A中30分答题常考题 1、Dijkstra算法+DFS（重点） （无负边权）单源最短路径问题万能通法，可以回溯路径，选取多条件最优路径 以在最短路径前提下的最小花费问题为例（其余条件根据题目变通） 在主函数中直接 Dijkstra(start); DFS(end);即可，path记录的就是有约束下的最短路径 int G[maxN][maxN]; //记录两点间距离 int C[maxN][maxN]; //记录两点间花费 int start; //记录起点 int d[ma..
PAT 1030 最短路径
xuxumoi
03-14 287
//1030 最短路径 #include #include using namespace std; int Dist[505 ][505] = {0}; int Cost[505][505] = {0}; int N, M, S, D; int CurrDis = 0; int ShortDis = 10000; int visit[505] = {0}; vector CurRoad;
【PAT甲级复习】 专题复习一：最短路径
Harryline的博客
09-05 238
文章目录1 无负权边的单源最短路径——Dijkstra1.1 邻接矩阵版：适用于V不超过1000的情况，复杂度O(2V22V^22V2)。1.2 邻接表版：复杂度O(V2+EV^2 + EV2+E)1.3 优先队列优化的Dijkstra1.4 记录最短路径1.5 多个标尺如何处理1.5.1 新增边权1.5.2 新增点权1.5.3 求最短路径条数1.6 多个标尺且比较复杂：Dijkstra + DFS1.6.1 Dijkstra默写模板1.6.2 DFS遍历所有最短路径模板2 有负权边的单源最短路径——Bel
PAT最短路径问题简单总结
Nin7a的博客
08-28 406
在PAT甲级真题目录中，涉及到最短路经问题求解的有1003、1018、1030、1087、1111。 一般来说，可以用最短路径算法（dijkstra、SPFA等）加上DFS进行求解。 我一般用这些数据结构： struct node{ int v;//与该地点相连的地点的序号 int cost;//两个地点之间的距离 //...由题意确定需要增加变量 node...
Java Dijkstra算法实现最短路径输出
"Java实现Dijkstra输出最短路径的实例" 在计算机科学中，Dijkstra算法是一种用于寻找图中两点间最短路径的算法，由荷兰计算机科学家艾兹格·迪科斯彻提出。这个算法特别适用于有向图，且边带有非负权重的情况。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值