Dijkstra算法:

解决的问题:

带权重的有向图上单源最短路径问题。且权重都为非负值。如果采用的实现方法合适,Dijkstra运行时间要低于Bellman-Ford算法。

思路:

如果存在一条从i到j的最短路径(Vi.....Vk,Vj),Vk是Vj前面的一顶点。那么(Vi...Vk)也必定是从i到k的最短路径。为了求出最短路径,Dijkstra就提出了以最短路径长度递增,逐次生成最短路径的算法。譬如对于源顶点V0,首先选择其直接相邻的顶点中长度最短的顶点Vi,那么当前已知可得从V0到达Vj顶点的最短距离dist[j]=min{dist[j],dist[i]+matrix[i][j]},应用了贪心的思想。根据这种思路,直接给出Dijkstra算法的伪代码,他可用于计算正权图的单源最短路径,同时适用于无向图和有向图。

清除所有点的标号

设d[0]=0,其他d[i]=INF

循环n次

{

在所有点的标号中,选出d值最小的结点x

给结点x标记

对于从x出发的所有边(x,y),更新d[y]=min{d[y],d[x]+w(x,y)}

}

除了求出最短路的长度外,使用Dijkstra算法也能很方便地打印出结点0到所有节点的最短路本身.

代码实现:

void dijkstra(int start)//从start点开始
{
int i,j,k;
memset(vis,0,sizeof(vis));//标记是否访问过
for(i=1; i<=n; i++)//n为总点数
{
if(i==start)
dis[i]=0;
else
dis[i]=INF;
}
for(i=1; i<=n; i++)
{
int r;
int min=INF;
for(j=1; j<=n; j++)
if(!vis[j]&&dis[j]<min)
{
min=dis[j];
r=j;
}
vis[r]=1;
for(k=1; k<=n; k++)//对所有从r出发的边进行松弛
if(dis[k]<(dis[r]+g[r][k]))
dis[k]=dis[k];
else
dis[k]=dis[r]+g[r][k];
}
return;
}

  Floyd算法:

负权重的边可以存在,但不能存在权重为负值的环路

算法考虑的是一条最短路径上的中间结点。

              算法核心思想:  三圈for循环

for (int k = 0; k < graph.getNumVex(); k++) {

                     for (int v = 0; v < graph.getNumVex(); v++) {

                            for (int w = 0; w < graph.getNumVex(); w++) {

                                   if (d[v][w] > d[v][k] + d[k][w]) {

                                          d[v][w] = d[v][k] + d[k][w];

                                          p[v][w] = p[v][k];// p[v][w]是v--w最短路径上 v的下一顶点

                                   }

                            }

                     }

              }

  

第一层 k是作为中间顶点

第二层 v是作为起始顶点

第三层 w是作为终点顶点

内层核心代码

以v为起点,w为终点,再以k作为v和w之间的中间点,去判断d[v][ w]和d[v][k] + d[k][w]的大小关系,如果d[v][w] > d[v][k] + d[k][w],说明找到从v→w的更短路径了,此时更改d[v][w]的值为d[v][k] + d[k][w]。

p[v][w]的值也要相应改成p[v][k]的值,因为 p[v][k]的值是v→k最短路径上v的后继顶点,而v→w这段最短路径是连接在v→k这段路径后面的,所以令所当然p[v][w]也要指向p[v][k]。

注意:最外层的k循环,前面的n此循环的结果跟后面n+1次循环的错做过程是息息相关,

三次循环完成后,各个顶点之间的最短路径权重会存储在d矩阵中:d[i][j]表示i→j的最短路径权重。

邻接矩阵算法实现:

void Floyd(MGraph g)
{
  int A[MAXV][MAXV];
  int path[MAXV][MAXV];
  int i,j,k,n=g.n;
  for(i=0;i<n;i++)
  for(j=0;j<n;j++)
  {   
A[i][j]=g.edges[i][j];
   path[i][j]=-1;
  }
  for(k=0;k<n;k++)
  {
  for(i=0;i<n;i++)
  for(j=0;j<n;j++)
  if(A[i][j]>(A[i][k]+A[k][j]))
  {
  A[i][j]=A[i][k]+A[k][j];
  path[i][j]=k;
  }
 }
}

 Bellman-Ford算法 

解决的问题:

一般情况下的单源最短路径问题,这里权重可以为负值。

Bellman-ford算法返回一个布尔值,一表明是否存在一个从源结点可以到达的权重为负的环路。如果存在这样一个环路,算法将告诉我们不存在解决方案,如果没有这种环路的存在算法将给出最短路径和他们的权重。

   Bellman-Ford算法的流程如下:
             给定图G(V, E)(其中V、E分别为图G的顶点集与边集),源点s,数组Distant[i]记录从源点s到顶点i的路径长度,初始化数组Distant[n]为, Distant[s]为0;

以下操作循环执行至多n-1次,n为顶点数:
    对于每一条边e(u, v),如果Distant[u] + w(u, v) < Distant[v],则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值;
    若上述操作没有对Distant进行更新,说明最短路径已经查找完毕,或者部分点不可达,跳出循环。否则执行下次循环;

为了检测图中是否存在负环路,即权值之和小于0的环路。对于每一条边e(u, v),如果存在Distant[u] + w(u, v) < Distant[v]的边,则图中存在负环路,即是说改图无法求出     单源最短路径。否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。

可知,Bellman-Ford算法寻找单源最短路径的时间复杂度为O(V*E).

  Bellman-Ford算法可以大致分为三个部分
    第一,初始化所有点。每一个点保存一个值,表示从原点到达这个点的距离,将原点的值设为0,其它的点的值设为无穷大(表示不可达)。
    第二,进行循环,循环下标为从1到n-1(n等于图中点的个数)。在循环内部,遍历所有的边,进行松弛计算。
    第三,遍历途中所有的边(edge(u,v)),判断是否存在这样情况:
    d(v) > d (u) + w(u,v)
    则返回false,表示途中存在从源点可达的权为负的回路。
 
之所以需要第三部分的原因,是因为,如果存在从源点可达的权为负的回路。则 应为无法收敛而导致不能求出最短路径。

#include<iostream>
#include<cstdio>
using namespace std;
#define MAX 0x3f3f3f3f
#define N 1010
int nodenum, edgenum, original; //点,边,起点
typedef struct Edge //边
{
int u,v;
int cost;
} Edge;
Edge edge[N];
int dis[N], pre[N];
bool Bellman_Ford()
{
for(int i = 1; i <= nodenum; ++i)
{
if(i==original)
dis[i]=0;
else
dis[i]=MAX;
}
for(int i = 1; i <= nodenum - 1; ++i)//循环n-1次
for(int j = 1; j <= edgenum; ++j)//遍历每条边
{
if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //松弛(顺序一定不能反~)
{
dis[edge[j].v] = dis[edge[j].u] + edge[j].cost;
printf("%d ",dis[edge[j].v]);
pre[edge[j].v] = edge[j].u;
}
printf("%d ",dis[edge[j].v]);
}
bool flag = 1; //判断是否含有负权回路
for(int i = 1; i <= edgenum; ++i)
if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)
{
flag = 0;
break;
}
return flag;
}
void print_path(int root) //打印最短路的路径(反向)
{
while(root != pre[root]) //前驱
{
printf("%d-->", root);
root = pre[root];
}
if(root == pre[root])
printf("%d\n", root);
}
int main()
{
scanf("%d%d%d", &nodenum, &edgenum, &original);
pre[original] = original;
for(int i = 1; i <= edgenum; ++i)
{
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);
}
if(Bellman_Ford())
for(int i = 1; i <= nodenum; ++i) //每个点最短路
{
printf("%d\n", dis[i]);
printf("Path:");
print_path(i);
}
else
printf("have negative circle\n");
return 0;
}

spfa算法:

算法流程

算法大致流程是用一个队列来进行维护。初始时将源加入队列。每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。直到队列为空时算法结束。

这个算法,简单的说就是队列优化的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
void Spfa()
{
for (int i(0); i<num_town; ++i)//初始化
{
dis[i] = MAX;
visited[i] = false;
}
queue<int> Q;
dis[start] = 0;
visited[start] = true;
Q.push(start);
while (!Q.empty()){
int temp = Q.front();
Q.pop();
for (int i(0); i<num_town; ++i)
{
if (dis[temp] + road[temp][i] < dis[i])//存在负权的话,就需要创建一个COUNT数组,当某点的入队次数超过V(顶点数)返回。
{
dis[i] = dis[temp] + road[temp][i];
if (!visited[i])
{
Q.push(i);
visited[i] = true;
}
}
}
visited[temp] = false;
}
}

  四种算法总结完了,都是东拼西凑的,自己学的也不好,还是静下心来好好学吧。也许有一天,你发觉日子特别的艰难,那可能是这次的收获将特别的巨大。这几天总是在抱怨生活,患得患失,却忘了自己为什么留下来暑期集训,因为你什么都没有,所以你必须努力!噶呜!~加油

————Anonymous.PJQ

最短路知识点总结(Dijkstra,Floyd,SPFA,Bellman-Ford)的更多相关文章

  1. poj1847 Tram(Dijkstra || Floyd || SPFA)

    题目链接 http://poj.org/problem?id=1847 题意 有n个车站,编号1~n,每个车站有k个出口,车站的出口默认是k个出口中的第一个,如果不想从默认出口出站,则需要手动选择出站 ...

  2. Dijkstra,floyd,spfa三种最短路的区别和使用

    这里不列举三种算法的实现细节,只是简单描述下思想,分析下异同 一 Dijkstra Dijkstra算法可以解决无负权图的最短路径问题,只能应付单源起点的情况,算法要求两个集合,开始所有点在第二个集合 ...

  3. hdoj2544 最短路(Dijkstra || Floyd || SPFA)

    题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=2544 思路 最短路算法模板题,求解使用的Dijkstra算法.Floyd算法.SPFA算法可以当做求解 ...

  4. 最短路径-Dijkstra+Floyd+Spfa

    Dijkstra算法: Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止.Dijkstra ...

  5. Dijkstra算法与Bellman - Ford算法示例(源自网上大牛的博客)【图论】

    题意:题目大意:有N个点,给出从a点到b点的距离,当然a和b是互相可以抵达的,问从1到n的最短距离 poj2387 Description Bessie is out in the field and ...

  6. 关于SPFA Bellman-Ford Dijkstra Floyd BFS最短路的共同点与区别

    关于模板什么的还有算法的具体介绍 戳我 这里我们只做所有最短路的具体分析. 那么同是求解最短路,这些算法到底有什么区别和联系: 对于BFS来说,他没有松弛操作,他的理论思想是从每一点做树形便利,那么时 ...

  7. ACM-最短路(SPFA,Dijkstra,Floyd)之最短路——hdu2544

    ***************************************转载请注明出处:http://blog.csdn.net/lttree************************** ...

  8. hdu1874 畅通project续 最短路 floyd或dijkstra或spfa

    Problem Description 某省自从实行了非常多年的畅通project计划后.最终修建了非常多路.只是路多了也不好,每次要从一个城镇到还有一个城镇时,都有很多种道路方案能够选择.而某些方案 ...

  9. 最短路问题(Bellman/Dijkstra/Floyd)

    最短路问题(Bellman/Dijkstra/Floyd) 寒假了,继续学习停滞了许久的算法.接着从图论开始看起,之前觉得超级难的最短路问题,经过两天的苦读,终于算是有所收获.把自己的理解记录下来,可 ...

  10. ACM/ICPC 之 最短路-Floyd+SPFA(BFS)+DP(ZOJ1232)

    这是一道非常好的题目,融合了很多知识点. ZOJ1232-Adventrue of Super Mario 这一题折磨我挺长时间的,不过最后做出来非常开心啊,哇咔咔咔 题意就不累述了,注释有写,难点在 ...

随机推荐

  1. javascript每日一练(十四)——弹性运动

    一.弹性运动 运动原理:加速运动+减速运动+摩擦运动: <!doctype html> <html> <head> <meta charset="u ...

  2. 一天一个类,一点也不累 之 Set接口

    我们的口号是:一天一个类,一点也不累-- 再次回忆一下集合相关的类图. 官方API上这样介绍这个接口: A collection that contains no duplicate elements ...

  3. C语言顺序栈实现

    /*数序栈*/ #include<stdio.h> #include<stdlib.h> #include<math.h> #define SElemType ch ...

  4. Swift 初见

    http://numbbbbb.gitbooks.io/-the-swift-programming-language-/chapter1/02_a_swift_tour.html 本页内容包括: 简 ...

  5. 14 - XML、JSON、PLIST对比和APP生命周期

    XML中间的 数据表达/传输数据的语言 优点:特别强大 强大到很多平台都有基于XML的独立语言,如MXML.HTML 缺点:传输小型数据时,特别啰嗦 size / speed = time JSON ...

  6. list和用vector区别(Vector相当于是数组,读写快,插入慢)

    stl提供了三个最基本的容器:vector,list,deque. vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随即存取,即[]操作符,但由 ...

  7. ZYSocket 4.3.5 SOCKET框架组 发布[NEW]

    最新代码请到 github: https://github.com/luyikk/ZYSOCKET 更新 4.3.5更新说明: 修复各种BUG. 重写了一份 protobuf-net 有什么用呢,不需 ...

  8. 安卓android WebView Memory Leak WebView内存泄漏

    Android WebView Memory Leak WebView内存泄漏 在这次开发过程中,需要用到webview展示一些界面,但是加载的页面如果有很多图片就会发现内存占用暴涨,并且在退出该界面 ...

  9. 使用ACE获取主机的IP地址

    使用ACE获取主机的IP地址,不知道为什么会有127.0.0.1? #include "stdafx.h" #include "ace\OS.h" #inclu ...

  10. HTTP的请求头标签If-Modified-Since

    一直以来没有留意过HTTP请求头的IMS(If-Modified-Since)标签. 最近在分析Squid的access.log日志文件时,发现了一个现象. 就是即使是对同一个文件进行HTTP请求,第 ...