dijkstra是一种单源最短路算法。在没有负权值的图上，vi..vj..vk是vi到vk最短路的话，一定要走vi到vj的最短路。所以每次取出到起点距离最小的点，从该点出发更新邻接的点的距离，如果更新成功则把新点加入priority_queue。储存图使用的是邻接表。代码如下：
#include <bits/stdc++.h>//有向图 using namespace std; //dijkstra 不适用于带负权的图 const int maxn = 1007, maxm = 20007, INF = 0x3f3f3f;// maxn比顶点数略大，maxm比边数略大 int head[maxn], vis[maxn], dis[maxn], fa[maxn]; int next[maxm], u[maxm], v[maxm], w[maxm]; typedef pair<int, int> pi;// pair排序策略是优先排前面，pair把距离放前面，点放后面 int n, m; void ini() { memset(vis, 0, sizeof(vis));//开始所有点都没被处理 memset(head, -1, sizeof(head));//所有点都没有边 for(int i = 0; i <= n; i++) dis[i] = INF;//起点到所有点距离为无穷大 } void dij(int s, int e) { priority_queue<pi, vector<int>, greater<int> > Q;//优先队列 dis[s] = 0; Q.push(make_pair(dis[s], s)); while(!Q.empty()) { pi u = Q.top(); Q.pop();//取出d最小的点 int x = u.second; if(x == e) break; if(vis[x])//处理过，跳过 continue; vis[x] = 1; for(int i = head[x]; ~i; i = next[i])//更新从当前d最小的点相邻点的距离 { if(dis[v[i]] > dis[x] + w[i]) { dis[v[i]] = dis[x] + w[i];//松弛成功 fa[v[i]] = x; Q.push(make_pair(dis[v[i]], v[i]));//把更新成功的点加入队列 } } } if(dis[e] == INF) return;//s到e无路径 vector<int> ans;//用vector从终点往起点找路径，也可以用递归 int temp = e; while(temp!=s) { ans.push_back(temp); temp = fa[temp]; } ans.push_back(s); for(int i = ans.size()-1; i >= 0; i--) printf("%d ", ans[i]); printf(" %d ", dis[e]); } int main() { //freopen("in.txt", "r", stdin); int t; scanf("%d", &t); while(t--) { scanf("%d%d", &n, &m); ini(); for(int i = 0; i < m; i++) { scanf("%d%d%d", u+i, v+i, w+i); next[i] = head[u[i]]; head[u[i]] = i;//建立邻接表 } int S, E;//起点终点 scanf("%d%d", &S, &E); dij(S, E); } return 0; }
dijkstra经典的一比，不过要求不能含负权，于是又学了下能处理带负权图的spfa：
spfa感觉有点像bfs，但bfs只处理一个节点一次，而spfa如果松弛了路径上经过的节点，就要对路径上之后的点都更新一遍。有负环的话，每走一遍负环，距离就减小环长，也就不存在最短路，所以假定不存在负环（或者判断一下有无负环）。代码如下：
#include <bits/stdc++.h>//有向图 using namespace std; const int maxn = 1007, maxm = 10007, INF = 0x3f3f3f3f; int head[maxn], in[maxn], dis[maxn], fa[maxn];//in标记在queue中的点 int u[maxm], v[maxm], w[maxm], next[maxm]; int n, m; void ini() { memset(in, 0, sizeof(in)); memset(head, -1, sizeof(head)); for(int i = 0; i <= n; i++) dis[i] = INF; } void print(int s, int e)//递归打印路径 { if(e!=s) print(s, fa[e]); printf("%d ", e); } void spfa(int s, int e)//有点像bfs，不过bfs不会处理之前处理过的点 { queue<int> Q; dis[s] = 0; in[s] = 1; Q.push(s); while(!Q.empty()) { int x = Q.front(); Q.pop(); in[x] = 0; for(int i = head[x]; ~i; i = next[i]) { if(dis[v[i]] > dis[x] + w[i]) { dis[v[i]] = dis[x] + w[i]; fa[v[i]] = x; if(!in[v[i]]) { Q.push(v[i]); in[v[i]] = 1; } } } } print(s, e); printf(" %d ", dis[e]); } int main() { freopen("in.txt", "r", stdin); int t; scanf("%d", &t); while(t--) { scanf("%d%d", &n, &m); ini(); for(int i = 0; i < m; i++) { scanf("%d%d%d", u+i, v+i, w+i); next[i] = head[u[i]]; head[u[i]] = i; } int s, e; scanf("%d%d", &s, &e); spfa(s, e); } return 0; }
多源最短路径有个floyd算法，其实就是离散讲的warshall闭包：（但是因为时间复杂度O（n^3）有点嫌弃2333），没自己实现一下，核心代码如下：
for(int k = 1; k <= n; k++) for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) if(g[i][j] > g[i][k] + g[k][j]) g[i][j] = g[i][k] + g[k][j];
思路是开始用邻接矩阵存放图，更新两点距离只能靠经过其他点中转，所以每次多允许经过一个点（即第一个循环），考虑最短路（第二三重循环）。
floyd好处是代码短，能一次求出所有节点之间的最短路。
今天收获挺大，总结一下稠密/无负权图用dijkstra，稀疏/有负权图用spfa，时间要求不高用floyd。
（心情依然很烂）