最短路径:BellmanFord / SPFA / Dijkstra

原创 2014年12月23日 00:12:25

Dijkstra算法只适用于边的权值非负的情况,一般复杂度为O(n*n)。
Bellman-Ford是最简单最粗暴最慢的,复杂度为O(nm),比O(n*n)更复杂(因为边m比点n多),但是适用范围比Dijistra更广,可以应用于边权值为负的情况,但是不能出现负环,要不然就永远收敛不了了。
//BellmanFord只需要存储边,直接将边放到足够大的数组里
#include<stdio.h>
#include<string.h>


#define N 100010
#define INF 0x3fffffff


typedef struct Edge
{
    int begin, end, value;
}ELink;


ELink edge[N];                      //存储边
int dist[N], n, m;


void BellmanFord(int start)
{
    int i, j;
    dist[start] = 0;                //源点到自己的距离为0
    for(i=1; i<=n; i++)             //外层是扫n遍,n个点
    {
        for(j=1; j<=m+m; j++)       //内层是扫2m遍,因为存储了2m条边
        {
            if(dist[ edge[j].end ] > dist[ edge[j].begin ] + edge[j].value)     //松弛
            {
                dist[ edge[j].end ] = dist[ edge[j].begin ] + edge[j].value;
            }
        }
    }
}


int main()
{
    int i, a, b, c;
    
    scanf("%d%d", &n, &m);
    for(i=1; i<=n; i++)                 //存储
        dist[i] = INF;
    for(i=1; i<=m; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        edge[i].begin = a;              //存储边
        edge[i].end = b;
        edge[i].value = c;


        edge[m+i].begin = b;            //反向存储一遍,否则相当于存的是有向边!!! 
        edge[m+i].end = a;
        edge[m+i].value = c;
    }
        
    BellmanFord(1);                     //不妨将点1作为源点
        
    for(i=1; i<=n; i++)
        printf("%d\n", dist[i]);            //输出源点到第n个点的最短距离
    return 0;
}

当然,这种无脑松弛会造成很多浪费,比如当前已经松弛完毕了,但是还没有达到n*m次,程序依旧会继续在n*m的循环里走下去,而此后并不会再发生松弛了。所以我们可以设置一个flag,一旦发现没有松弛,直接break,会大大提升效率。
void BellmanFord(int start)
{
    int i, j;
    dist[start] = 0;                //源点到自己的距离为0
    for(i=1; i<=n; i++)             //外层是扫n遍,n个点
    {
        int change = 0;
        for(j=1; j<=m+m; j++)       //内层是扫2m遍,因为存储了2m条边
        {
            if(dist[ edge[j].end ] > dist[ edge[j].begin ] + edge[j].value)     //松弛
            {
                dist[ edge[j].end ] = dist[ edge[j].begin ] + edge[j].value;
                change = 1;
            }
        }
        if(!change)
        {
            break;
        }
    }
}

最后再说明强调一点——如果是无向图,存储边的话一定要正反存两遍,否则会导致无向图存成了有向图,这样就会导致最后的求解错误。
而且,如果想更简单一点的话,直接存成邻接矩阵也是可以的,会简单很多,不过浪费了不少存储空间。

SPFA是最好使相对来说写起来也不复杂,一般正常的情况下复杂度为O(km),也可以理解为O(m),性价比最好!力荐!!!想有更多更深的理解,可以参考如下文章http://blog.sina.com.cn/s/blog_a46817ff01015g9h.html。


SPFA是对Bellman-Ford的一种优化,其核心思路就是:
不必一直不停地松弛下去,如果当前节点A被松弛了(也就是说当前节点到Source Point的距离变小了),那么A的邻接点B(有可能B通过A得到到达Source Point的最短路径)就需要重新松弛一下:如果B经由A到达Source Point为最短路径,那么B一定会被松弛,否则B不会被松弛。

所以,我们需要构建一个队列,当A被松弛之后,所有A的邻接点都要被重新检测一下,看看需不需要被松弛。于是所有A的邻接点入队。之后再从队列中取出一个节点,进行相同的操作,直到队空,证明所有能松弛的都松弛完了,结束。这样就避免了Bellman-Ford盲目不停地松弛n*m次,使得算法效率大大提高。

//由于SPFA对BellmanFord进行了优化,只更新一个点周围的点,
//所以需要知道和一个点相连的点都有哪些,因此采用邻接表的形式
#include<stdio.h>
#include<stdlib.h>


#define V 200
#define N 10010
#define INF 0x3fffffff


typedef struct Edge                     //邻接表的链节点构造
{
    int to, value;
    struct Edge *link;
}ELink;


typedef struct Ver                      //邻接表的顶点节点构造
{
    int vertex;
    ELink *link;                        //链节点指针
}VLink;


VLink G[V];                             //顶点节点型数组,最多V个
int queue[N], inqueue[N], dist[N];      //队;判断是否在队里;各个点到源点的距离


void SPFA(int start)
{
    int top = 0, rear = -1;
    ELink *tmp;


    dist[start] = 0;                    //此三句对源点进行操作
    queue[++rear] = start;
    inqueue[start] = 1;
    while(top <= rear)                  //直到队空(有点儿像广度搜索)
    {
        for(tmp = G[queue[top]].link; tmp != NULL; tmp = tmp->link) //遍历队中顶点节点的所有链节点
        {
            if(dist[tmp->to] > dist[queue[top]] + tmp->value)       //符合条件则松弛
            {
                dist[tmp->to] = dist[queue[top]] + tmp->value;
                if(inqueue[tmp->to] != 1)                           //如果没有入队则入队,并标记
                {
                    queue[++rear] = tmp->to;
                    inqueue[tmp->to] = 1;
                }
            }
        }
        inqueue[queue[top]] = 0;               //出队,并更改标记
        ++top;
    }
}


void append(int a, int b, int c)
{
    ELink *p, *q;
    G[a].vertex = a;
    p = (ELink *)malloc(sizeof(ELink));
    p->to = b;
    p->value = c;
    p->link = NULL;
    if(G[a].link == NULL)
        G[a].link = p;
    else
    {
        q = G[a].link;
        while(q->link)
            q = q->link;
        q->link = p;
    }
}


int main()
{
    int n, m, i, a, b, c;


    scanf("%d%d", &n, &m);
    for(i=1; i<=n; i++)                 //从1开始初始化,距离赋INF
        dist[i] = INF;
    for(i=0; i<m; i++)                  //构造邻接表
    {
        scanf("%d%d%d", &a, &b, &c);
        append(a, b, c);                //eg:构造1-->3的链节点
        append(b, a, c);                //eg:构造3-->1的链节点
    }


    SPFA(3);                            //所有点到第一个点的最短距离


    for(i=1; i<=n; i++)                 //输出所有的最短距离
        printf("%d ", dist[i]);


    return 0;
}

上面的算法因为用到了邻接表,所以在邻接表的构造上还是费了不少功夫的。当然不用邻接表也是可以的,使用邻接矩阵会使算法变得更简单易写,不过多浪费了存储空间:
#include <iostream>
using namespace std;


#define N 10000                     // 边的最大个数
#define V 200                       // 顶点的最大个数
#define INF 0x3fffffff
int edge[N][N];                     // 邻接矩阵,记录边
int dist[V], queue[V], inqueue[V];  // 到源点的距离;队列;是否入队
int pre[V];                         // 记录每个点的前导点,用以输出路径
int n, m;                           // 顶点个数;边的个数


void init()                         // 初始化edge/dist/pre
{
    cin >> n >> m;
    for(int i = 1; i <=n; i++){
        dist[i] = INF;
        pre[i] = i;                 // 每个点的终结点为自己
    }


    for(int i = 1; i <= n; i++){
        for(int j = 1; j <=n; j++){
            edge[i][j] = INF;
        }
    }
    
    int row, col, value;
    while(m--){
        cin >> row >> col >> value;
        edge[row][col] = edge[col][row] = value;
    }


}


void SPFA(int start)
{
    int top = 0, rear = -1;
    dist[start] = 0;                // 初始化source point
    queue[++rear] = start;
    inqueue[start] = 1;


    while(top <= rear){
        int vertex = queue[top];
        for(int i = 1; i <= n; i++){
            int value = edge[vertex][i];
            if(value < INF && dist[i] > dist[vertex] + value){
                dist[i] = dist[vertex] + value;
                pre[i] = vertex;
                if(!inqueue[i]){
                    queue[++rear] = i;
                    inqueue[i] = 1;
                }
            }
        }
        ++top;
        inqueue[vertex] = 0;
    }
}


void printPath(int v)               // 按照pre逆序输出路径  
{
    while(v != pre[v]){
        cout << v << "<--";
        v = pre[v];
    }
    cout << v << endl;
}


int main()
{
    init();
    cout << "Input a source point: ";
    int start;
    cin >> start;
    SPFA(start);


    for(int i = 1; i <=n; i++){
        cout << "Vertex: " << i << endl
            << "Dist to Source Point: " << dist[i] << endl
            << "Path: ";
        printPath(i);
    }
    return 0;
}

算法运行结果如下:
pArch➜  tmp  ᐅ  ./spfa
7 9
1 2 10
1 3 2
2 5 1
3 4 2
3 6 11
4 5 4
4 6 6
5 7 7
6 7 3
Input a source point: 1
Vertex: 1
Dist to Source Point: 0
Path: 1
Vertex: 2
Dist to Source Point: 9
Path: 2<--5<--4<--3<--1
Vertex: 3
Dist to Source Point: 2
Path: 3<--1
Vertex: 4
Dist to Source Point: 4
Path: 4<--3<--1
Vertex: 5
Dist to Source Point: 8
Path: 5<--4<--3<--1
Vertex: 6
Dist to Source Point: 10
Path: 6<--4<--3<--1
Vertex: 7
Dist to Source Point: 13
Path: 7<--6<--4<--3<--1

最后说的是Dijkstra算法,如果不优化则复杂度为O(n*n),相对来说最难写,且复杂度还不如SPFA好,所以性价比不是最好,但是跟Prim求最小生成树极其相似,两个算法可以想通。详情请参考http://blog.csdn.net/puppylpg/article/details/41440459,这里就不再贴代码了。

而且,在这些点存储的过程中,点从1到n,所以我更倾向于从数组的[1]开始存储,感觉这样的话在很多方面写起来都比较容易。

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

spfa ,Dijkstral,bellmanFord求最短路径

求起点到终点的最短路径。 Dijkstral: #include #include using namespace std; const int INF=100000000; int ...

单源最短路径---BellmanFord,Dijkstra

1.最短路径相关问题 (1)单源最短路径:顶点s0到各个点的最短路径 (2)单终点最短路径:各个点到终点s的最短路径 (3)单对顶点的最短路径问题:点v到点u的最短路径 (4)每对顶点间的最短路径:对...

Dijkstra Bellman-Ford SPFA 几种最短路径求法 基本理论

最短路问题 一、概念: 在图论中最短路径有着非常广泛的应用,而由于应用的方法不同也形成了多种求最短路径的方法,而对于不同类的问题虽然每种方法都可以用,不过各有其最优的实现方法。 首先对于最短路径...

【最短路径】:Dijkstra算法、SPFA算法、Bellman-Ford算法和Floyd-Warshall算法

求最短路径最常用的算法有: Dijkstra算法、SPFA算法、Bellman-Ford算法和Floyd-Warshall算法。 Dijkstra算法、SPFA算法、Bellman-Ford算法这三个...

hdoj-1874 畅通工程续【最短路径--dijkstra&&floyd&&spfa】

题目:http://acm.hdu.edu.cn/showproblem.php?pid=1874 本题需要注意的地方是 起点终点并不是第一个 最后一个 是另外给定的 如果不存在从S到T的路线,就输出...

杭电1874-畅通工程续(最短路径,dijkstra,spfa,floyd)

畅通工程续 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Tota...

最短路径 -- Floyd-Warshall & Dijkstra & spfa 学习和思考

最近在强化自己的图论算法,首先翻看以前的图论题目(此题需翻墙) Google APAC 2016 University Graduates Test Round A:Problem C. gCamp...

hdu3790 最短路径问题(spfa||dijkstra+两种限制条件)

http://acm.hdu.edu.cn/showproblem.php?pid=3790 题意:多了一个花费的限制条件,距离相等则选花费少的。 思路:直接在原来的判断条件上加就行,...

POJ 1847 Tram (简单最短路径dijkstra-floyd-spfa)

题目链接:http://poj.org/problem?id=1847 大意:给你N个交叉路口,每个路口都对应几个路口,第一个不用开关,其余要扳动开关,S到T,问你需要扳动几次开关 思路:把第一个赋值...

hdoj-2066 一个人的旅行【最短路径--dijkstra&&spfa&&floyd】

题目:http://acm.hdu.edu.cn/showproblem.php?pid=2066 解题思路: 把城市a,b看成起点和终点,time看成两者之间的距离      从而转化成最短路径问题...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)