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

最新推荐文章于 2021-03-28 20:22:15 发布
最新推荐文章于 2021-03-28 20:22:15 发布
阅读量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 679
文章目录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
最短路径之Dijkstra
weixin_51364599的博客
10-07 1万+
Dijkstra算法 function getCostByPositiveGraph (graph,start) { let cost = {} for(let i in graph){ for (let j in graph[start]){ if(i === graph[start][j]['target']){ cost[i] = graph[start][j]['value'] b
【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 510
目前PAT甲级中涉及Dijkstra的题目有如下几题：                                           1003 Emergency (25)                                 1018 Public Bike Management (30)                                         ...
最短路径 Dijkstra 算法
qq_40075784的博客
06-16 742
最短路径 Dijkstra 算法解析数据结构输入思路输出Python 代码 最短路径可以说是出名的算法问题了，无论现实中还是数据结构上都十分有意义，两点之间距离最短的走法。基于离散数学图论，对于给定的点级和边集，边的权值模拟距离。在无法确定中转还是直达最快的情况下，通过算法找出最短的距离。 解析 一般而言，Dijkstra 算法适用于单源点（入口）有向边，经过改进可适用于无向边。数据表示需要一种方法，处理则是核心。 数据结构 为了方便描述，所有点以数字或字母表示，以0或a作为入口。 对于边集的表示两种方法
最短路径问题—Dijkstra算法及相关例题
热门推荐
水木今山的博客
12-05 2万+
最近在做算法题的时候总是遇到Dijkstra相关的题目，之前虽然学过图论的一些算法，但第一次做这类题时完全不知从何入手。看了一些博客，并且在PAT上折腾了几题后，发现一些常用的模板与套路，因此在这里进行一个总结。关于Dijkstra的理论知识可以参考这篇博客：最短路径问题-Dijkstra算法详解 Dijkstra算法 Dijkstra算法往往和dfs结合在一起考，因此这里给出一个求解基础Dijk...
PAT (Advanced Level) Practice 1003 Dijkstra算法扩展，求最短路径数量+最大权值和
四轩茶屋
01-15 603
一、概述 本题属于数据结构中图的部分，中心思想是利用dijkstra算法，找到源点和目标点的最短路径数量。输出最短路径数量以及一条路径上可供调遣的最大人数。核心问题是理解dijkstra算法的应用。理论部分十分容易理解，在源点周围找到第一个距离最短的点，更新再找第二个第三个，手动模拟很方便，但是转换为代码没那么简单。第二是如何找到最短路径的条数以及最大人数，这需要在原算法的基础上改进，还是不那么...
PAT 数据结构 06-图5. 旅游规划（25）Dijkstra最短路径算法
兔子哥哥的博客
07-16 3100
有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。 输入格式说明： 输入说明：输入数据的第1行给出4个正整数N、M、S、D，其中N（2 输出格式说明： 在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾
利用Dijkstra算法实现记录每个结点的所有最短路径
最美的时光
05-29 7004
我们知道，Dijkstra是解决单源最短路问题的，并且最基本的算法仅能求出最短路的长度，而不能输出路径，本文基于Dinjkstra进行改进，使之能记录源点到任意点的所有最短路径。使用vector<int>来记录一条路径，因为每个结点可能有多条最短路径，因此把这些路径都装在一个vector中，因此可以用一个vector<vector<int> >来表示一个结点的所有最短路径，把所有结点的最短路径都存放起来，又需要一个vector容器，因此所有结点的所有最短路径的集合可以用vector<vector<vecto
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 178
#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 832
最短路径算法是PAT甲级考试常考算法，具体说来，最短路径包括Dijkstra算法、Floyd算法，其余的Bellman-Ford和SPFA基本不会考（参《算法笔记》胡凡，曾磊著） 目录 一、最短路径基本概念与问题分类 1.基本概念 2.问题分类 二、Dijkstra算法 1.伪代码 2.示意图 3.参考代码 4.升级 5.Dijkstra+DFS   一、最短路径基本概...
Java Dijkstra算法实现最短路径输出
"Java实现Dijkstra输出最短路径的实例" 在计算机科学中，Dijkstra算法是一种用于寻找图中两点间最短路径的算法，由荷兰计算机科学家艾兹格·迪科斯彻提出。这个算法特别适用于有向图，且边带有非负权重的情况。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值