一、最短路径概念：
1、最短路路径树
在最短路径算法结束时，Gπ为最短路径树Gπ=(Vπ,Eπ)
Vπ={v∈V: π[v]≠NIL}∪{s}
Eπ={(π[v],v)∈E: v∈Vπ-{s}}
最短路径不一定唯一，∴最短路路径树也不一定唯一
2、松弛技术——逼近及最终达到最短路径
(基础)
引理25.1：最短路径的子路径也是最短路径
(不等式:逼近最短路径)
引理25.3：所有有向边都“有权利”(be entitled to)做最短路径的最后一条边
设G=(V,E)是一个有向加权图，其加权函数为w:E→R，源节点为s。
则对所有边(u,v)∈E，有
dis(s,v)≤dis(s,u)+w(u,v)，其中dis(i,j)为结点i到j的最短路径(d[v]是s~~>v最短路径的估计)
initialize-single-source(G,s)
for 每个顶点v∈V[G]
do d[v] <- ∞
pi[v] <- NIL
d[s] <- 0
relax(u,v,w)
if d[v] > d[u]+w(u,v)
then d[v] <- d[u]+w(u,v)
pi[v] <- u
每一步松弛实际上就是“引理25.3”的实践!
(等式:达到最短路径)
引理25.7：设G=(V,E)是一个有向加权图，其加权函数为w:E→R，源节点为s。
且对于某些结点u,v∈V，设s~~>u->v是G的一条最短路径。
假定过程initialize-single-source(G,s)已对G进行了初始化，且
随即对G的边执行了包含调用RELAX(u,v,w)的一个松弛操作序列。
如果在调用前的任何时刻d[u]=dis(s,u)，则调用以后d[v]=dis(s,v)
始终保持成立。
下面两个图帮助记忆引理25.7，灰常重要——
A. 万事俱备，只欠东风
-------------------------------------------------------------------------------------------------------->time
(1)initialize-single-source(G,s) (2)d[u]=dis(s,u) (3)东风 ：relax(u,v,w) (4)d[v]=dis(s,v)
B. s ~~~~~~~~~~~> u -> v
d[u]已更新到dis(s,u) 若s~~>u->v是某条最短路径，只需relax(u,v,w)一下，就可最终更新d[v]到dis(s,v)
总结：前面两个引理分别是“所有推导的基础（引理25.1）”和“逼近最短路径（25.3）”，但没有真正到达最短路径。通过引理25.7，我们真正达到了最短路径。据此，可以设计出各种算法，来实现引理25.7的前提；此时，dis[]中自然就是我们需要的单源最短路径鸟:)
3. 最短路的4种重要算法
（1）Dijkstra
Haha，我能感觉到(I CAN REALLY FEEL) Dijkstra算法在被设计时，目标就是达到“引理25.7”的前提，这样，当算法执行完了所有顶点v的d[v]就自动 减小到dis[s,v]了！Can you feel it?吼吼吼吼
（2）Bellman-Ford
另外，BellmanFord算法也和Dijkstra一样，也来自“引理25.7”，因为在算法运行的过程中完成了“所有顶点的所有排列方式”对应的边的松弛操作 。例如，假设有顶点1,2,3，则这个算法考虑到了一下三种顺序的松弛:
松弛边<1,2>, 松弛边<2,3>;
松弛边<1,3>, 松弛边<3,2>;
松弛边<2,1>, 松弛边<1,3>;
松弛边<2,3>, 松弛边<3,1>;
松弛边<3,1>, 松弛边<1,2>;
松弛边<3,2>, 松弛边<2,1>.
private static boolean bellmanFord(double[][] w, int n, int s, double[] d,
int[] p) {
for (int i = 1; i <= n; i++) {
d[i] = w[s][i];
p[i] = s;
}
for (int k = 1; k <= n - 1; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (d[i] + w[i][j] < d[j]) {
d[j] = d[i] + w[i][j];
p[j] = i;
}
}
}
}
boolean flag = true;
for (int i = 1; i <= n && flag == true; i++) {
for (int j = 1; j <= n; j++) {
if (d[i] + w[i][j] < d[j]) {
flag = false;
break;
}
}
}
return flag;
}
（3）DAG的单源点最短路径
DagShortestPath(G, w, s)
{
topologically sort the nodes in G
//initialization
for each vertex v in G
{
distance[v] = infinite
parent[v] = NULL;
}
distance[s] = 0
for each vertex v in G, taken in topologically sorted order
{
//relax
for each edge w[u][v]
{
if (distance[v] > distance[u] + w[u][v])
{
distance[v] = distance[u] + w[u][v]
parent[v] = u
}
}
}
}
注意：在理解“Dijkstra算法”和“DAG的单源点最短路径”时，注意在算法执行的过程中，最短路径树逐渐从根节点（源点）生长出来^^ 这种生长顺序保证了“引理25.7”的顺利实现！
（4）SPFA
SPFA算法（Shortest Path Finding Algorithm）是一种单源最短路算法。因为其算法速度快，代码简单，并可以计算负权，所以SPFA算法在信息学竞赛领域已经逐渐替代其他单源最短路算法。SPFA本质上是Bellman-Ford算法的优化 。
Sam: 我觉得，SPFA的实现上和Dij更相似。两者实现的区别在于:
Dij 每次从优先级队列（按照d[]升序）中取出最小者x，加入S，然后松弛x的邻接边；
SPFA 每次从普通队列中取出队首元素x，不加入S（没有S和V-S的概念），然后松弛x的邻接边，松弛成功后还要入队(前者不用)。
算法大致流程是用一个队列来进行维护。初始时将源加入队列。每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：
设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。
SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右。
SPFA算法（Shortest Path Faster Algorithm），也是求解单源最短路径问题的一种算法，用来解决：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算，他的基本算法和Bellman-Ford一样，并且用如下的方法改进： 1、第二步，不是枚举所有节点，而是通过队列来进行优化 设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环，还可以通过下面的方法： 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。
SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。
邻接表(第一条邻接边序号数组head[],有向边序号数组el{y,c,next})实现SPFA单源最短路径算法:
void Spfa()
{
d[S]=0;
v[S]=true;
deque <int> q;
for(q.push_back(S);!q.empty();)
{
int x=q.front();
q.pop_front();
for(int k=head[x];k!=-1;k=el[k].next)
{
//每次处理一条邻接边<x,i>: el[k]
//el[k].y 指向的顶点
//el[k].c 有向边el[k]的代价
//el[k].next 从x出发的下一条邻接边
int y=el[k].y;
if(d[y]>d[x]+el[k].c)
{
d[y]=d[x]+el[k].c;
//仅当顶点y不在队列中时，才入队；否则即使松弛了，也不作任何处理
if(!v[y])
{
v[y]=true; //顶点第一次y被访问到v[y]=true
//保持队列中所有元素i按照d[i]递增排列
if(!q.empty())
{
if(d[y]>d[q.front()])
q.push_back(y);
else
q.push_front(y);
}
else
q.push_back(y);
}
}
}
v[x]=false;
}
return ;
}
*********************************************************************
二、性能及其他
1、BellmanFord和Dijkstra执行之前都需要相同的初始化
2、BellmanFord注意：
1)有向图中没有边的顶点设置为Integer.MAX_VALUE/2
（若设置为Integer.MAX_VALUE可能导致越界错误，而且这个错误时RE）
2)有向图中，i=j时，m[i][j]=0
3、关于速度：
BellmanFord: O(VE) --当用权值矩阵表示图时(通常是这么做的)-->O(V^3)
Dijkstra: O(V^2) ——普通数组实现优先队列
O((V+E)lgV) ——最小二叉堆实现优先队列
O(VlgV+E) ——斐波那契堆实现优先队列
4、我认为，一般情况下，Dijkstra比BellmanFord要快一些；但Dijkstra要求边权非负，而BellmanFord只要求
单源点不能到达负权回路即可（这是最短路径问题都需要保证的，否则最短路可能为-∞）。看来老天是公平的，不
会让你什么都占优势!
5、“单汇点的最短距离 ”问题可以转换为: 对转置图的“单源点最短路径”! 千万别去计算每对顶点的最短距离TT
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
