最短路问题

单源最短路

概念：

从一个点到所有点的最短距离

所有边权都是正数

情况：

如果题目给的是稠密图，那么用朴素Dijkstra算法

如果是稀疏图，就用堆优化版的Dijkstra算法

朴素Dijkstra算法（时间复杂度：O(n^2)）——  n表示点的数量

步骤：

1.初始化距离：dist[1] = 0, disr[i] = 正无穷

2.for循环1到n，找到不在s中距离最近的点放到t中，再把t放到s中。最后用t更新其他点的距离

补充：s为已确定最短距离的点。

稠密图用邻接矩阵存储，稀疏图用邻接表存储

当m~n^2时通常被认为是稠密图， 当m~n时，被认为是稀疏图

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510;

int n, m;
int g[N][N];//邻接矩阵
int dist[N];//每个点到起始点的距离
bool st[N];//每个点的最短路是否确定

int Dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;

	for (int i = 0; i < n; i++) {
		int t = -1;
		for (int j = 1; j <= n; j++) {
			if (!st[j] && (t == -1 || dist[t] > dist[j]))
				t = j;
		}

		st[t] = true;

		for (int j = 1; j <= n; j++) {
			//用1~t的距离更新1~j的长度
			dist[j] = min(dist[j], dist[t] + g[t][j]);
		}
	}

	if (dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m;

	memset(g, 0x3f, sizeof g);

	while (m--)
	{
		int a, b, c;
		cin >> a >> b >> c;
		g[a][b] = min(g[a][b], c);//这里用min是防止重边，遇到重边选最小的那条
	}

	int t = Dijkstra();

	cout << t << endl;
	return 0;
}

堆优化版的Dijkstra算法（时间复杂度：O(mlogn)）——  m表示边

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

typedef pair<int, int> PII;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;//邻接表
int dist[N];//每个点到起始点的距离
bool st[N];//每个点的最短路是否确定

void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int Dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;

	priority_queue<PII, vector<PII>, greater<PII>> heap;//小根堆
	heap.push({ 0, 1 });

	while (heap.size())
	{
		auto t = heap.top();//取队头，也就是最小的那个
		heap.pop();

		int ver = t.second, distance = t.first;
		if (st[ver]) continue;

		for (int i = h[ver]; i != -1; i = ne[i]) {
			int j = e[i];
			//更新距离
			if (dist[j] > distance + w[i]) {
				dist[j] = distance + w[i];
				heap.push({ dist[j], j });
			}
		}

	}

	if (dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m;

	memset(h, -1, sizeof h);

	while (m--)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}

	int t = Dijkstra();

	cout << t << endl;
	return 0;
}

存在负权边

情况：

如果题目给出限制：最多经过k条边的最短路径（限制边数），那么用Bellman-Ford。

否则用SPFA。

Bellman-Ford（时间复杂度：O(nm)）

步骤：

两重循环，第一次循环，循环n次，第二次循环遍历所有边，循环的同时更新所有边。

dist[b] = min(dist[b]，dist[a] + w); ——  松弛操作

循环完之后，一定有dist[b] <= dist[a] + w;——  三角不等式

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510, M = 10010;
int n, m, k;
int dist[N], backup[N];

struct Edge
{
	int a, b, w;
}edges[M];

int bellman_ford()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;

	for (int i = 0; i < k; i++) {
		memcpy(backup, dist, sizeof dist);//防止串连
		for (int j = 0; j < m; j++) {
			int a = edges[j].a, b = edges[j].b, w = edges[j].w;
			dist[b] = min(dist[b], backup[a] + w);//更新距离
		}
	}
	
	//不写dist[n] == 0x3f3f3f3f是因为可能存在负权边把dist[n]给更新了
	//也就是假如n-1个点能够到第n个点，当它们两个的边时负的，而题目到不了第n-1的点(距离为无穷)
	//就会导致第n的点dist不是）0x3f3f3f3f了。
	if (dist[n] > 0x3f3f3f3f / 2) return -1;
	else return dist[n];
}

int main()
{
	cin >> n >> m >> k;

	for (int i = 0; i < m; i++) {
		int a, b, w;
		cin >> a >> b >> w;
		edges[i] = { a, b, w };
	}

	int t = bellman_ford();
	if (t == -1) cout << "No" << endl;
	else cout << t << endl;
	return 0;
}

SPFA（时间复杂度：一般为O(m)，最坏O(nm) ）

区别：

与Bellman-ford相比，SPFA的优化在于多了一个队列，用来存储进行了距离更新的点（在Bellman-ford算法是遍历了全部的边，但有一些边是无须遍历更新的。），每次取点就从队列里来取。

SPFA其实与堆优化版的Dijkstra算法很像。

另外，常用SPFA来判断是否存在负环

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

typedef pair<int, int> PII;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;//邻接表
int dist[N];//每个点到起始点的距离
bool st[N];//每个点的最短路是否确定

void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int spfa()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;

	queue<int> q;
	q.push(1);
	st[1] = true;

	while (q.size()) {
		int t = q.front();
		q.pop();

		st[t] = false;
		for (int i = 0; i != -1; i = ne[i]) {
			int j = e[i];
			if (dist[j] > dist[t] + w[i]) {
				dist[j] = dist[t] + w[i];
				if (!st[j]) {
					q.push(j);
					st[j] = true;
				}
			}
		}
	}

	if (dist[n] == 0x3f3f3f3f)return -1;
	return dist[n];
}

int main()
{
	cin >> n >> m;

	memset(h, -1, sizeof h);

	while (m--)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}

	int t = spfa();

	if (t == -1) cout << "No" << endl;
	else cout << t << endl;
	return 0;
}

多源汇最短路

概念：

任意两个点的最短距离（起点、终点是不确定的）

Floyd算法（时间复杂度：O(n^3)）

基本原理：

利用三层循环来不断更新每个点到每个点的最短路。

这里k必须放在第一层循环中。

代码：

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

const int N = 210;
const int INF = 0x3f3f3f3f;

int n, m, Q;
int d[N][N];//邻接矩阵

void floyd()
{
	for (int k = 1; k <= n; k++)
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

int main()
{
	cin >> n >> m >> Q;
	//初始化邻接矩阵
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			if (i == j) d[i][j] = 0;
			else d[i][j] = INF;
	//给邻接矩阵赋值
	while (m--) {
		int a, b, w;
		cin >> a >> b >> w;
		
		d[a][b] = min(d[a][b], w);//防止重边，如果有选最短的边
	}

	floyd();

	while (Q--) {
		int a, b;
		cin >> a >> b;
		if (d[a][b] > INF / 2) cout << "No" << endl;
		else cout << d[a][b] << endl;
	}

	return 0;
}