（spfa与Dijkstra的思想与区别）

spfa：

使用已经更新过的节点去更新其他节点（包括已经被更新过的节点），一个节点可以多次入队（被更新过的节点，在更新过其他节点后还可以被更新）

dijkstra:

使用已经更新过的节点中距离起点距离最小的点去更新其他没被更新过的节点，一个节点只能入队一次（被更新过的节点，在更新过其他节点后不会再被更新） 

———————————————————————————————————————————

 朴素版spfa（bellman-ford算法）

基本思路：

n次迭代，每一次循环所有边(a,b,w,边a,b权重为w)，执行dist[a]=min(dist[b],dist[a]+w)

这个更新操作称为：松弛操作

循环结束后一定满足三角不等式：dist[a]<=dist[b]+w

此算法迭代k次的含义为，不超过k条边，到达某个点的最短距离

据此，我们可以知道，当第n次更新后的值与n-1次更新不同时，图中就有负环。

所以bellman_ford算法可以用来判断负环

时间复杂度为O(nm)

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
using namespace std;
typedef pair<double, int > PDI;
typedef pair<int, int> PII;
const int N = 500 + 5, M = 10000 + 5, INF = 0x3f3f3f3f;
 
int n, m, k;
int dist[N], backup[N];
struct edge {
	int a, b, w;
}edge[M];
 
void bellman_ford() {
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for (int i = 1; i <= k; i++) {
		memcpy(backup, dist, sizeof dist);
		for (int j = 1; j <= m; j++) {
			int a = edge[j].a, b = edge[j].b, w = edge[j].w;
			dist[b] = min(dist[b], backup[a] + w);
		}
	}
 
}
 
int main() {
	scanf("%d%d%d", &n, &m, &k);
	for (int i = 1; i <= m; i++) {
		scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].w);
	}
	bellman_ford();
	if (dist[n]>INF/2)cout << "impossible" << endl;
	else {
		cout << dist[n] << endl;
	}
	return 0;
}
 
 

队列优化版： 

 
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
 
using namespace std;
typedef pair<int, int >PII;
typedef long long LL;
const int N = 1e5+5;
vector<PII>G[N];
int v[N], d[N];
int n, m;
 
void spfa() {
	memset(d, 0x3f3f3f3f, sizeof(d));
	d[1] = 0;
	queue<int>q;
	q.push(1);
	v[1] = 1;
	int t;
	while (!q.empty()) {
		t = q.front();
		q.pop();
		v[t] = 0;
		for (int i = 0,j,dist; i <G[t].size(); i++) {
			j = G[t][i].first;
			dist = G[t][i].second;
			if (d[j] > d[t] + dist) {
				d[j] = d[t] + dist;
				if (v[j] == 0) {
					v[j] = 1;
					q.push(j);
				}
			}
		}
	}
}
 
 
int main() {
	cin >> n >> m;
	for (int i = 1,a,b,t; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &t);
		G[a].push_back({ b,t });
	}
 
	spfa();
	if (d[n] == 0x3f3f3f3f)
		cout << "impossible" << endl;
	else
		cout << d[n] << endl;
 
	return 0;
}
 
 

 朴素版Dijkstra：

Dijkstra算法的使用一定不能存在负权边

朴素版Dijkstra算法和prim算法几乎一模一样，核心就是松弛操作

 
 
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
 
using namespace std;
typedef long long LL;
const int N = 500 + 5;
int G[N][N], d[N], v[N];
int n, m;
 
int Dijkstra() {
	int ret = 0;
	memset(d, 0x3f3f3f3f, sizeof(d));
	d[1] = 0;
	for (int i = 1; i <= n; i++) {
		int x = -1;
		for (int j = 1; j <= n; j++) {
			if (!v[j] && (x == -1 || d[x] > d[j])) {
				x=j;
			}
		}
		v[x] = 1;
		for (int j = 1; j <= n; j++) {
			if (!v[j]) {
				d[j] = min(d[j], d[x] + G[x][j]);
			}
		}
	}
	if (d[n] == 0x3f3f3f3f) {
		return -1;
	}
	return d[n];
}
 
int main() {
	scanf("%d%d", &n, &m);
	memset(G, 0x3f3f3f3f, sizeof(G));
	for (int i = 1,a,b,t; i <= m; i++) {
		scanf("%d%d%d",&a,&b, &t);
		G[a][b] = min(G[a][b], t);
	}
 
 
	int ans = Dijkstra();
	
	cout << ans << endl;
	return 0;
}

优先队列优化版：

核心还是松弛操作

 
 
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
 
using namespace std;
typedef long long LL;
const int N = 1e6;
vector<pair<int,int>>G[N];
int v[N],d[N];
int n, m;
 
typedef struct node{
    int first,second;
}node;
 
 
bool operator>(const node& a, const node& b) {
	return a.first > b.first;
}
 
void Dijkstra() {
	memset(d, 0x3f3f3f3f, sizeof(d));
	d[1] = 0;
	priority_queue<node, vector<node>, greater<node>>q;
	q.push({ 0,1 });
	int t1, t2;
	while (!q.empty()) {
		t1 = q.top().first;
		t2 = q.top().second;
		q.pop();
		if (v[t2])
			continue;
		v[t2] = 1;
		for (int i = 0; i < G[t2].size(); i++) {
			if (d[G[t2][i].first] > t1 + G[t2][i].second) {
				d[G[t2][i].first] = t1 + G[t2][i].second;
				q.push({ d[G[t2][i].first] ,G[t2][i].first });
			}
		}
	}
}
 
 
int main() {
	cin >> n >> m;
	for (int i = 1, x, y, z; i <= m; i++) {
		scanf("%d%d%d", &x, &y, &z);
		G[x].push_back({ y,z });
	}
 
	Dijkstra();
 
	if (d[n] == 0x3f3f3f3f)
		cout << -1 << endl;
	else {
		cout << d[n] << endl;
	}
 
	return 0;
}