dijkstra是一种单源最短路算法。在没有负权值的图上，vi..vj..vk是vi到vk最短路的话，一定要走vi到vj的最短路。所以每次取出到起点距离最小的点，从该点出发更新邻接的点的距离，如果更新成功则把新点加入priority_queue。储存图使用的是邻接表。代码如下：
#include <bits/stdc++.h>//有向图
using namespace std;
//dijkstra 不适用于带负权的图
const int maxn = , maxm = , 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, , sizeof(vis));//开始所有点都没被处理
memset(head, -, sizeof(head));//所有点都没有边
for(int i = ; i <= n; i++)
dis[i] = INF;//起点到所有点距离为无穷大
} void dij(int s, int e)
{
priority_queue<pi, vector<int>, greater<int> > Q;//优先队列
dis[s] = ;
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] = ;
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()-; i >= ; i--)
printf("%d ", ans[i]);
printf("\n%d\n", 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 = ; 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 ;
}
dijkstra经典的一比，不过要求不能含负权，于是又学了下能处理带负权图的spfa：
spfa感觉有点像bfs，但bfs只处理一个节点一次，而spfa如果松弛了路径上经过的节点，就要对路径上之后的点都更新一遍。有负环的话，每走一遍负环，距离就减小环长，也就不存在最短路，所以假定不存在负环（或者判断一下有无负环）。代码如下：
#include <bits/stdc++.h>//有向图
using namespace std;
const int maxn = , maxm = , 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, , sizeof(in));
memset(head, -, sizeof(head));
for(int i = ; 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] = ;
in[s] = ;
Q.push(s);
while(!Q.empty())
{
int x = Q.front();
Q.pop();
in[x] = ;
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]] = ;
}
}
}
}
print(s, e);
printf("\n%d\n", 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 = ; 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 ;
}
多源最短路径有个floyd算法，其实就是离散讲的warshall闭包：（但是因为时间复杂度O（n^3）有点嫌弃2333），没自己实现一下，核心代码如下：
for(int k = ; k <= n; k++)
for(int i = ; i <= n; i++)
for(int j = ; 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。
（心情依然很烂）