P3371 【模板】单源最短路径（弱化版）（Dijkstra+链式前向星+优先队列）蒟蒻上路

【模板】单源最短路径（弱化版）

传送门：

P3371 【模板】单源最短路径（弱化版） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

思路

最短路板子题，一般简易图论题分为两步

1. 构图
2. 对应算法实现

---

构图（三种形式）

1. 邻接矩阵

   

   看这个图就知道邻接矩阵最大的缺点就是费空间，空间大小是结点数的平方（对稀疏图和结点较多的图不太友好），但是对结点数少，关系密集的简单图很友好，用这个很好写题，但是一般题目不会这样

2. 邻接表

   

   用链表来存什么图都感觉很方便，只存每个点的邻接点，

3. 链式前向星

   

   静态链表，相较于邻接表可能缺乏了一定的灵活性但是链式前向星无论是在构图还是用图都比邻接表好写

   这边就不提上述两种构图方法了，直接看链式前向星，比赛做题我都比较推荐用这个，因为我看到链表、结构体、指针组合在一起就头疼

   搜索智能精选 (baidu.com) 可以看一下这个

   struct node{
   	int to,w,next;
   	//to表示源节点到to这个结点
   	//w表示这条路径上的权值
   	//next表示下一条邻接边的下标
   	//实则就是一条边存了这条路径的终点，权值和与它同起点的另外边
   }edge[M];//一般是M=N*N（N表示最多结点数，M表示最多边数）
   int head[N];//存了以该下标为起点的第一条边是（然后找到第一条边以后就依靠第一条边的邻边……以此找下去，把以该点为起点的边全找完）
   void init(){
   	cnt=0;//从第0条边开始一条边一条边加进去
   	memset(head,-1,sizeof head);//刚开始起点没有路就是-1跟邻接表中指向NULL一样
   }
   void add_edge(int u,int v,int w){//u起点，v终点，w权值
   	edge[cnt].to=v;//这条路的终点是v
   	edge[cnt].w=w;//这条路的权值是w
   	edge[cnt].next=head[u];//因为是头插法，所以把上一个结点的终点当作这一个结点的终点
   	head[u]=cnt++;//而上一个结点的终点就是指向这一个结点（也就是这条边的编号cnt），然后开始下一条路，cnt要加1，cnt++先赋值再加加就不再赘述了
   }//然后每次找一个结点的邻接点都可以依靠边的标号来找
   

---

Dijkstra算法介绍

算法特点：

迪科斯彻算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

算法的思路

Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。 然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点， 然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。 然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。

讲的花里胡哨，其实就是广度优先搜索，然后先把路短的（总权值小的）走了，然后全走完了就ok了

这边讲一下为什么要用优先队列，因为优先队列可以使每次把总权值小的路走了（这里有贪心的思路，需要着重思考以下），那么后面肯定是大的了

const int INF=0x3f3f3f3f;//初始化每条路都是“无穷大”
int dis[N];//起点到该点的最短路
bool vis[N];//该点是否走过，用作优化时间
struct point{
	int vex;//终点（指的是起点到这这个点）
	int dis;//起点到这个点的距离
	friend bool operator<(point a,point b){//友元函数重载<运算符，当然这边可改成其他的方式
//https://blog.csdn.net/yanyanwenmeng/article/details/78153192
//如果是友元函数为什么要这样做参考：https://zhuanlan.zhihu.com/p/636108068
//大概解释一下就是友元函数没有this指针，也就是不会去取已有结构体里的元素的，而如果不是友元函数是成员函数的话这里只要一个形参就行
		return a.dis>b.dis;//这里要注意优先队列第一个元素表示后一个元素就行了不用记什么大根堆小根堆优先级的 
	}
};
priority_queue<point>q;
void dijkstra(int start){
	rep(i,1,n) dis[i]=INF;//初始化
	dis[start]=0;//自己到自己路径为0
	point p;
	p.vex=start;
	p.dis=0;
	q.push(p);//把初始点压入队列
	while(!q.empty()){
		int u=q.top().vex;//存取起点要到的点
		q.pop();//弹出
		if(vis[u])continue;//因为这个存在不一定是bfs一层一层搜的而有可能搜了这一层的某一个发现这个是当前队列的首部那么继续走这给结点的下一个结点而不走与他并行的结点，所以有可能走到其他点的时候会碰到这个点，那么这个点已走过就不用管了直接找一个
		vis[u]=true;//如果之前没有遇到过，现在遇到了，那么现在就是最短路
		for(int i=head[u];i!=-1;i=edge[i].next){//与邻接表找下一节点一样，自行思考一下
			int to=edge[i].to;//存一下为了简化代码
			if(!vis[to]&&dis[to]>dis[u]+edge[i].w){
			//!vis[to]如果这个点之前有人走过，说明已获得到该点的最短路，不用再看这个点了
			//dis[to]>dis[u]+edge[i].w就是之前的路比现在的路长那么就走现在的路
				dis[to]=dis[u]+edge[i].w;//当前路径最短路更改
				p.vex=to;//终点更改
				p.dis=dis[to];//当前路径最短路更改
				q.push(p);//压入当前点
			}
		}
	}
	rep(i,1,n){
		if(dis[i]==INF) cout<<(1<<31)-1<<" ";//1<<31==2的31次
		else cout<<dis[i]<<" ";
	}
}

大家对于Dijkstra算法的思考主要在于贪心+bfs这两点理解了之后主要就是构图和取点的操作了

这里思路有问题可以评论或私信我，大家一起学习进步！

本篇中样例图参考各大博客和百度等（若侵权请联系我）

AC code（这里不做解析了）

// Problem: 
//     P3371 【模板】单源最短路径（弱化版）
//   
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3371
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<algorithm>
//#include<cstdio>
#include<queue>
#include<cstring>
#define ll long long 
#define endl '\n'
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>(b);i--)
#define N 10010 //1e6+100 
#define M 500010

using namespace std;
int n,m,s,cnt;
int u,v,w;
const int INF=0x3f3f3f3f;
struct node{
	int to,w,next;
}edge[M];
int head[N],dis[N];
bool vis[N];
struct point{
	int vex;
	int dis;
	friend bool operator<(point a,point b){
		return a.dis>b.dis;
	}
};
priority_queue<point>q;
void init(){//初始化前向星
	cnt=0;
	memset(head,-1,sizeof head);
}


void add_edge(int u,int v,int w){//头插法
	edge[cnt].to=v;
	edge[cnt].w=w;
	edge[cnt].next=head[u];
	head[u]=cnt++;
}


void dijkstra(int start){
	rep(i,1,n) dis[i]=INF;
	dis[start]=0;
	point p;
	p.vex=start;
	p.dis=0;
	q.push(p);
	while(!q.empty()){
		int u=q.top().vex;
		q.pop();
		if(vis[u])continue;
		vis[u]=true;
		for(int i=head[u];i!=-1;i=edge[i].next){
			int to=edge[i].to;
			if(!vis[to]&&dis[to]>dis[u]+edge[i].w){
				dis[to]=dis[u]+edge[i].w;
				p.vex=to;
				p.dis=dis[to];
				q.push(p);
			}
		}
	}
	rep(i,1,n){
		if(dis[i]==INF) cout<<(1<<31)-1<<" ";
		else cout<<dis[i]<<" ";
	}
}
void test(){
	for(int i=1;i<=n;i++){
		cout<<i<<" : ";
		for(int j=head[i];j!=-1;j=edge[j].next){
			cout<<edge[j].to<<" ";
		}
		cout<<endl;
	}
}

int main(){
	//ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n>>m>>s;
	init();
	rep(i,1,m){
		cin>>u>>v>>w;
		add_edge(u,v,w);
	}
	//test();
	dijkstra(s);
	
	return 0; 
} 

有问题请评论或私信我，谢谢！

有共同学习需求的可以加入洛谷团队：https://www.luogu.com.cn/team/66731