(图论)最短路径基础算法模板总结，考前必备！！！

背景

以洛谷一道简单的模板题总结一下解决最短路的算法:
1、Dijkstra邻接矩阵版，邻接链表版；
2、Dijkstra+堆优化；
3、解决图含负权含环的SPFA算法

P4779 【模板】单源最短路径（标准版）

题目描述
给定n 个点，m 条有向边的带非负权图，请你计算从 s出发，到每个点的距离。
数据保证你能从 s出发到任意点。

输入格式
第一行为 n, m, s三个正整数 。 第二行起行，每行三个非负整数u i,v i,w i ，表示从 u到 v有一条权值为w 的有向边。

输出格式
输出一行 n 个空格分隔的非负整数，表示 s 到每个点的距离。

输入输出样例
输入

4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出

0 2 4 3

我的代码：

一、邻接矩阵版的Dijkstra

1、适用于结点数数不超过1000的图；
2、适用稠密图时；
3、时间复杂度：O(V^2)；

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000;
const int INF = 1000000010;
int n,m,s,u,v,w;
bool flag[maxn] = {false};//用于标记点是否已访问过
int mp[maxn][maxn] = {0},d[maxn];//d[maxn]储存起点到每个点的最短路径
void Dijkstra()
{
	fill(d,d + maxn,INF);
	d[s] = 0;
	for (int i = 1 ;i <= n ;i++)
	{
		int u = -1,minNum = INF;
		for (int j = 1 ;j <= n ;j++)//寻找距离起点最短距离的点
		{
			if (flag[j] == false && d[j] < minNum)
			{
				u = j;
				minNum = d[j];
			}
		}
		if (u == -1) return;
		flag[u] = true;//标记访问的点
		for (int j = 1 ;j <= n ;j++)//遍历与该点所有接通的路径
		{
			if (flag[j] == false && mp[u][j] != 0 && d[u] + mp[u][j] < d[j])
				d[j] = d[u] + mp[u][j];
		}
	}
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	for (int i = 0 ;i < m ;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		mp[u][v] = w;//如果是无向图则再加上mp[v][u] = w;
	}
	Dijkstra();
	for (int i = 1 ;i <= n ;i++)
	{
		printf("%d",d[i]);
		if (i < n) printf(" ");
		else printf("\n");
	}
	return 0;
}

二、邻接链表版的Dijkstra

1、适用于稀疏图；
2、用结构体存储下一个点和边权数据；
3、时间复杂度:O(V^2)；

我的代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int INF = 1000000010;
struct Node
{
	int v,dis;//v为点，dis为点到v的距离
}node;
int n,m,s,u,d[maxn];
bool flag[maxn] = {false};//标记每个点是否访问过
vector<Node> mp[maxn];
void Dijsktra()
{
	fill(d,d + maxn,INF);
	d[s] = 0;
	for (int i = 1 ;i <= n ;i++)
	{
		int u = -1,minNum = INF;
		for (int j = 1 ;j <= n ;j++)
		{
			if (flag[j] == false && minNum > d[j])
			{
				u = j;
				minNum = d[j];
			}
		}
		if (u == -1) return;
		flag[u] = true;
		for (int j = 0 ;j < mp[u].size() ;j++)
		{
			int v = mp[u][j].v;
			if (flag[v] == false && d[u] + mp[u][j].dis < d[v])
				d[v] = d[u] + mp[u][j].dis;
		}
	}
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	for (int i = 0 ;i < m ;i++)
	{
		scanf("%d%d%d",&u,&node.v,&node.dis);
		mp[u].push_back(node);
	}
	Dijsktra();
	for (int i = 1 ;i <= n ;i++)
	{
		printf("%d",d[i]);
		if (i < n) printf(" ");
		else printf("\n");
	}
	return 0;
}

上述做法：从复杂度来看，上述简单的Dijkstra主要是外层循环O(V)与内层循环（寻找最小值的d[u]需要O(V) ）产生的，时间复杂度为O(V^2)，V是结点个数;

因此有了Dijkstra + 堆优化，最简洁的做法是直接使用STL中的优先队列priority_queue，来代替上述的查找过程,这样复杂度可以降为O(VlogV )（关于priority_queue的介绍和使用可以查看这篇博文：priority_queue的用法介绍和简单例题）

三、Dijkstra + 堆优化版

1、使用C++STL的priority_queue，其底层由堆实现；
2、用邻接链表的方法实现；
2、时间复杂度：O(VlogV)；

简述：
1、优化Dijkstra的部分是：每轮寻找源点到目前最短距离的点的过程；用优先队列优化的话，我们要单独建立存储点和源点到该点的距离的结构体，用priority_queue设置优先级从低到高，每回把更新后的点筛入优先队列（不用担心优先队列里面是否还有相同的点，因为它会自动把其中最小距离的那个排在前面，当弹出的不是最小距离那个点时，我们直接跳过它），然后优先队列自动把源点到各点最短距离的那个点排在顶部，直到队列为空。

我的代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int INF = 1000000010;
struct Node//存储点，和源点到该点的最短距离
{
	int v,d;//v:点的序号，d:源点到该点的最短距离
	friend bool operator<(Node n1,Node n2)//重载优先级
	{
		return n1.d > n2.d;
	}
};
struct Edge//存储边权
{
	int v,dis;//v:点的序号；dis:上一个点到此点边权
}edge;
int n,m,s,u,d[maxn];//d[maxn]源点到各点的最小距离
bool flag[maxn] = {false};//标记是否已遍历
vector<Edge> mp[maxn];//构建图
void Dijkstra()
{
	fill(d,d+maxn,INF);
	priority_queue<Node> q;
	d[s] = 0;
	q.push(Node{s,0});//把源点和其距离存入优先队列
	while (!q.empty())
	{
		Node temp = q.top();
		q.pop();
		if (flag[temp.v] == true) continue;//最短距离的点在前已经遍历过；当弹出的不是最小距离那个点时，跳过；
		flag[temp.v] = true;
		for (int i = 0 ;i < mp[temp.v].size() ;i++)
		{
			int v = mp[temp.v][i].v;
			if (flag[v] == false && temp.d + mp[temp.v][i].dis < d[v])
			{
				d[v] = temp.d + mp[temp.v][i].dis;
				q.push(Node{v,d[v]});//将更新的点放入队列
			}
		}
	}
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	for (int i = 0 ;i < m ;i++)
	{
		scanf("%d%d%d",&u,&edge.v,&edge.dis);
		mp[u].push_back(edge);
	}
	Dijkstra();
	for (int i = 1 ;i <= n ;i++)
	{
		printf("%d",d[i]);
		if (i < n) printf(" ");
		else printf("\n");
	}
	return 0;
}

三、解决图中含有负权含环的SPFA

1、理解：只有当某个顶点u的d[u]值改变时，从他出发的边的邻接点v的d[v]值才可能改变;
2、用num数组来存储各点入队次数，当某个点入队次数大于总点的个数时，则说明有负环；如果事先知道没有负环则可以不用num数组；
3、此处的flag数组标记是为确定点序号是否在队列中，不是表示是否遍历过‘；
4、时间复杂度O(kE)，k为常数，E为图的边数

我的代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int INF = 1000000010;
int n,m,s,u,v,w,num[maxn] = {0},d[maxn];
bool flag[maxn] = {false};
struct Node
{
	int v,dis;
}node;
vector<Node> mp[maxn];
bool SPFA()
{
	fill(d,d+maxn,INF);
	queue<int> q;
	q.push(s);
	d[s] = 0;
	num[s]++;
	flag[s] = true;//源点入队标记
	while (!q.empty())
	{
		int temp = q.front();
		q.pop();
		flag[temp] = false;//出队标记
		for (int i = 0 ;i < mp[temp].size() ;i++)
		{
			int v = mp[temp][i].v;
			if (d[v] > d[temp] + mp[temp][i].dis)
			{
				d[v] = d[temp] + mp[temp][i].dis;
				if (flag[v] == false) //如果没在队列里则入队
				{
					q.push(v);
					flag[v] = true;
					num[v]++;
					if (num[v] >= n) return false;					
				}
			}		
		}
	}
	return true;
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	for (int i = 0 ;i < m ;i++)
	{
		scanf("%d%d%d",&u,&node.v,&node.dis);
		mp[u].push_back(node);
	}
	SPFA();
	for (int i = 1 ;i <= n ;i++)
	{
		printf("%d",d[i]);
		if (i < n) printf(" ");
		else printf("\n");
	}
	return 0;
}