最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解

好基友YanBaoC大神五天的呕心沥血,在此膜拜一下。出处:http://www.cnblogs.com/Yan-C/p/3916281.html 。


在本文中因为邻接表在比赛中不如前向星好写,而且前向星效率并不低所以,本文的代码 存图只有两种:前向星 or邻接矩阵

本文包含如下内容:

         1、Bellman-Ford算法

   2、Dijkstra算法(代码 以邻接矩阵为例)    &&    Dijkstra + 优先队列的优化(也就是堆优化)

   3、floyd-Warshall算法(代码 以邻接矩阵为例)

   4、SPFA(代码 以前向星为例)

   5、BFS 求解最短路

   6、路径还原

序章    :

            在开始最短路的算法之前,需要先说明一下   松弛   (relax)

    松弛是什么? 这个问题在我刚刚开始接触最短路的时候也是一脸茫然啊。但是在读了《算法导论》后我知道了。有资源的同学可以看一下。

    不想看厚厚的书的同学看这儿 : 松弛其实很简单,就是     用现在的最小路径去更新其他的路径。用C/C++写其实就是这个样子。 

 if(dis[i]>dis[k]+G[k][i]){
2     dis[i] = dis[k]+G[k][i];
3 }
4 //其中dis[i]  是其他的路径
5 //dis[k]  是现在的最小路径
6 //G[k][i]  是现在的最小路径的点到其他路径点的权值。


在《算法导论》中松弛这一步  若条件成立 不仅更新了路径距离 && 更新了前驱。此处未写出。

插播一下

     在讲完松弛操作之后,最短路算法开始之前,说一下什么是  最短路径的估计值

    我们的源点用s表示。

    在这里我们用数组   dis[N]  来存储最短路径,dis[N]数组为源点到其他点的最小距离。

    那么最最开始的最短路径的估计值 也就是对 dis[N] 的初始化喽。

    一般我们的初始化都是初始化为 dis[N] = +∞ , But 在一些时候是初始化为dis[N] = 0的(“一些时候”后面再讲)。

    But 源点是要初始化为0的, dis[s] = 0,因为s—>s的距离为0;

 

#define MAX 9999999
2  
3 int dis[203];
4  
5 fill(dis,dis+n,MAX);//不知此函数的可以百度
6 dis[s] = 0;

我们也可以这样原始的初始化。

#define MAX 9999999
 
int dis[203];
int i;
 
for(i=0;i<n;i++)
    dis[i] = MAX;
dis[s] = 0;

1、Bellman-Ford算法 :

     bellman-ford 算法解决的是一般情况下的单源最短路径问题,其边可以为负值。bellman-ford算法可以判断图是否存在负环,若存在负环会返回一个布尔值。当然在没有负环存在的    情况下会返回所求的最短路径的值。

    bellman-ford() :算法如下

    1   图的初始化等操作

    2  for i = 1 to |G.V| - 1   //  |G.V|  为图 G的点的总数

    3    for each edge(u,v)∈G.E   //G.E 为图 G 的边

    4           relax(u,v,w) 也就是if  v.d>u.d+w(u,v)  , v.d = u.d+w(u,v);

    5  for each edge(u,v)∈G.E

    6     if v.d>u.d+w(u,v)  //v.d为出发源点到结点v的最短路径的估计值  u.d亦如此  w(u,v) 为u结点到v结点的权重值(通俗点就是u—>v的花费)。

    7      return false;

    8  return true

    此算法分为3步:

    1)  第1行对图进行初始化,初始化dis[N] = +∞,dis[s] = 0;

     2)  第2~4行为求最短路的过程,是对图的每一条边进行|V|-1次松弛操作,求取最短路径。

     3) 第5~8行为对每条边进行|V|-1次松弛后,检查是否存在负环并返回相应的布尔值,因为进行|V|-1次松弛后若没有负环则v.d的值确定不变,若有负环则会继续进行松弛操作,因为一个数+负数是一定比它本身要小的。

    此算法的 时间复杂度为O(VE)。

    

eg :

    我们做一个简单的题练习一下:

    多组输入。第一行给你两个数n(代表点),m(代表边)

    第2—m+1行 ,每行三个数u,v,  w。0<=u,v<n,  w>=0;

    第m+2行两个数 s, t  。 s为源点,t为要到达的目的点。

    求s到t 的最短路,若存在最短路输出最短路的值,否则输出-1。

这也就是hdu 的题目     http://acm.hdu.edu.cn/showproblem.php?pid=1874

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define MAX 9999999

using namespace std;

struct node
{
    int u, v, w;
};
node edge[2003];
int n, m, s, t;

void bellman_ford()
{
    int i, j;
    bool flag;//用于优化的
    int dis[203];//保存最短路径
    //初始化
    fill(dis,dis+n,MAX);//其他点为+∞
    dis[s] = 0;//源点初始化为0
     m = m<<1;//此处和m = 2*m是一样的,因为建立的无向图
    for(i=1;i<n;i++)//进行|V|-1次
    {
        flag = false;//刚刚开始标记为假
        for(j=0;j<m;j++)//对每个边
        {   
            //if  (v.d>u.d+w(u,v))
            if(dis[edge[j].u]>dis[edge[j].v]+edge[j].w){//进行松弛操作
                dis[edge[j].u] = dis[edge[j].v]+edge[j].w;//松弛成功
                flag = true;//若松弛成功则标记为真
            }
        }
        if(!flag)//若所有的边i的循环中没有松弛成功的
            break;//退出循环
        //此优化可以大大提高效率。
    }
    printf("%d\n",dis[t]==MAX?-1:dis[t]);//输出结果
}

int main()
{
    int i;

    while(scanf("%d %d",&n,&m)==2){//输入点的总数n,边的总数m
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);//每条边的u,v,w的输入
            edge[i+m].u = edge[i].v;//因为为无向图所以u—>v和v—>u 是一样的
            edge[i+m].v = edge[i].u;//So...
            edge[i+m].w = edge[i].w;//So...
        }
        scanf("%d %d",&s,&t);//起点和终点
        bellman_ford();//调用算法部分
    }
    return 0;
}

说明  : 因为此图w>=0,所以是一定没有负环的,因此没有 3)第5~8行的操作

 

对于bellman-ford算法 推荐使用结构体数组存储,因为比较方便和简洁,当然也可以用其他的数据结构。

用到的数据结构

 struct node
2 {
3     int u, v, w;//u 为起点,v为终点,w为u—>v的权值
4 };
5 node edge[2003];


主函数对边的读取和存储


int main()
{
    int i;

    while(scanf("%d %d",&n,&m)==2){//输入点的总数n,边的总数m
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);//每条边的u,v,w的输入
            edge[i+m].u = edge[i].v;//因为为无向图所以u—>v和v—>u 是一样的
            edge[i+m].v = edge[i].u;//So...
            edge[i+m].w = edge[i].w;//So...
        }
        scanf("%d %d",&s,&t);//起点和终点
        bellman_ford();//调用算法部分
    }
    return 0;
}


bellman-ford算法求最短路 C/C++版

void bellman_ford()
{
    int i, j;
    bool flag;//用于优化的
    int dis[203];//保存最短路径
    //初始化
    fill(dis,dis+n,MAX);//其他点为+∞
    dis[s] = 0;//源点初始化为0
     m = m<<1;//此处和m = 2*m是一样的,因为建立的无向图
    for(i=1;i<n;i++)//进行|V|-1次
    {
        flag = false;//刚刚开始标记为假
        for(j=0;j<m;j++)//对每个边
        {   
            //if  (v.d>u.d+w(u,v))
            if(dis[edge[j].u]>dis[edge[j].v]+edge[j].w){//进行松弛操作
                dis[edge[j].u] = dis[edge[j].v]+edge[j].w;//松弛成功
                flag = true;//若松弛成功则标记为真
            }
        }
        if(!flag)//若所有的边i的循环中没有松弛成功的
            break;//退出循环
        //此优化可以大大提高效率。
    }
    printf("%d\n",dis[t]==MAX?-1:dis[t]);//输出结果
}

对于优化 的解释:若图中存在负环的情况下外循环需要|V|-1次循环,若不存在负环,平均情况下的循环次数是要小于|V|-1次,当所有边没有松弛操作的时候我们就得到了

最后的答案,没有必要继续循环下去,So有了这个简单的优化。

    对于bellman-ford算法求最短路  没有负环的情况下已经说明了,下面说一下求负环的强大功能

eg. 题目传送门 http://poj.org/problem?id=3259

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define MAX 9999999

using namespace std;

struct node
{
    int u, v, w;//u 为起点,v为终点,w为u—>v的权值
};
node edge[5203];
int n, m;//n 点数   m 边数

bool bellman_ford()
{
    int i, j;
    bool flag;
    int dis[503];//保存最短路径

    fill(dis,dis+n,MAX);//初始化
    dis[1] = 0;//因为判断是否有负环,对整个图而言,So  s = 1;
    //一下部分为 2) 第2~4行的操作
    for(i=1;i<n;i++)//共需进行|V|-1次
    {
        flag = false;//优化   初始化为假
        for(j=0;j<m;j++)//对每一条边
        {
            // if  u.d>v.d+w(u,v) , u.d = v.d+w(u,v);
            if(dis[edge[j].u]>dis[edge[j].v]+edge[j].w){//进行松弛
                dis[edge[j].u] = dis[edge[j].v]+edge[j].w;//松弛操作成功
                flag = true;//松弛成功变为真
            }
        }
        if(!flag)//若每条边没有松弛
            break;//跳出循环
    }
    // 一下部分为 3) 第5~8行的操作
    for(i=0;i<m;i++)
        if(dis[edge[i].u]>dis[edge[i].v]+edge[i].w)//进行|V|-1次操作后  有边还能进行松弛  说明
            return true;//存在负环
    return false;//不存在负环
}

int main()
{
    int t, k, i;

    scanf("%d",&t);//输入测试数据的组数
    while(t-- && scanf("%d %d %d",&n,&m,&k)){//输入点数,正边数,负边数
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);//输入u,v,w;
            edge[i+m].u = edge[i].v;//双向
            edge[i+m].v = edge[i].u;//双向
            edge[i+m].w = edge[i].w;//双向
        }
        m <<= 1;//正边为双向 所以m = m*2;
        for(i=m;i<m+k;i++)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);//存负边数(单向)
            edge[i].w = -edge[i].w;//负边就要是负的
        }
        m += k;//单向,So不需要*2
        printf("%s\n",bellman_ford()?"YES":"NO");//输出结果
    }
    return 0;
}
题目大意: 第一行 输入一个数  是表示几组测试数据

    第二行  三个数 N(点的个数),M(正边的个数),W(负边的个数) 注意 :正边为双向的,负边为单向的。

    然后 M行u,v,w;

    再然后W行u,v,w;

    求这个图是不是存在负环。 有 YES 没NO。

    所用数据结构 :

 struct node
2 {
3     int u, v, w;//u 为起点,v为终点,w为u—>v的权值
4 };
5 node edge[5203];


主函数对数据的获取。

int main()
{
    int t, k, i;

    scanf("%d",&t);//输入测试数据的组数
    while(t-- && scanf("%d %d %d",&n,&m,&k)){//输入点数,正边数,负边数
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);//输入u,v,w;
            edge[i+m].u = edge[i].v;//双向
            edge[i+m].v = edge[i].u;//双向
            edge[i+m].w = edge[i].w;//双向
        }
        m <<= 1;//正边为双向 所以m = m*2;
        for(i=m;i<m+k;i++)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].w);//存负边数(单向)
            edge[i].w = -edge[i].w;//负边就要是负的
        }
        m += k;//单向,So不需要*2
        printf("%s\n",bellman_ford()?"YES":"NO");//输出结果
    }
    return 0;
}

bellman-ford  算法求解

bool bellman_ford()
{
    int i, j;
    bool flag;
    int dis[503];//保存最短路径

    fill(dis,dis+n,MAX);//初始化
    dis[1] = 0;//因为判断是否有负环,对整个图而言,So  s = 1;
    //一下部分为 2) 第2~4行的操作
    for(i=1;i<n;i++)//共需进行|V|-1次
    {
        flag = false;//优化   初始化为假
        for(j=0;j<m;j++)//对每一条边
        {
            // if  u.d>v.d+w(u,v) , u.d = v.d+w(u,v);
            if(dis[edge[j].u]>dis[edge[j].v]+edge[j].w){//进行松弛
                dis[edge[j].u] = dis[edge[j].v]+edge[j].w;//松弛操作成功
                flag = true;//松弛成功变为真
            }
        }
        if(!flag)//若每条边没有松弛
            break;//跳出循环
    }
    // 一下部分为 3) 第5~8行的操作
    for(i=0;i<m;i++)
        if(dis[edge[i].u]>dis[edge[i].v]+edge[i].w)//进行|V|-1次操作后  有边还能进行松弛  说明
            return true;//存在负环
    return false;//不存在负环
}

上面只是第一种对负环存在的判断,继续下一种:

    我们前面已经说过  若没有负环外循环最多进行|V|-1次即可,就可得到最短路径,那么若存在负环,则第|V|次操作就说明存在负环。

bool bellman_ford()
{
    int i, j;
    bool flag;
    int dis[503];//保存最短路径

    fill(dis,dis+n,MAX);//初始化
    dis[1] = 0;//因为判断是否有负环,对整个图而言,So  s = 1;
    //一下部分为 2) 第2~4行的操作
    for(i=0;i<n;i++)//共需进行|V|-1次
    {
        flag = false;//优化   初始化为假
        for(j=0;j<m;j++)//对每一条边
        {
            // if  u.d>v.d+w(u,v) , u.d = v.d+w(u,v);
            if(dis[edge[j].u]>dis[edge[j].v]+edge[j].w){//进行松弛
                dis[edge[j].u] = dis[edge[j].v]+edge[j].w;//松弛操作成功
                flag = true;//松弛成功变为真
            }
        }
        if(!flag)//若每条边没有松弛
            break;//跳出循环
        //下面这一部分代替了  3) 第5~8行的操作
        //因为对于V个点 你最多需要进行|V|-1次外循环,如果有负环它会一直进行下去,但是只要进行到第V次的时候就说明存在负环了
        if(i == n-1)//若有
            return true;//返回有负环
    }
    return false;//不存在负环
}

 bellman-ford 算法也说的差不多了,对于此算法的SPFA优化 ,我们在本文的后面部分单独讲解。

    不知大家还记不记的上面的那个许多个But 中的那个But dis[N] = 0呢?

    给大家留下一个问题吧。

    这个问题是《算法导论》上的一个思考题,问题是这样的 :

    你如果知道一个带权重的有向图中 存在一个负环,那么请你设计一个有效&&正确的算法列出所有属于该环路上的结点。

2、dijkstra算法 :   (贪心策略)

    Dijkstra算法解决的是带权重的有向图上单源最短路径问题,该算法要求所有边的权重都为正值。

    在此有的同学可能就要问了,为什么不能处理负值呢?

    Why????

    Dijkstra算法不是绝对的不能处理权重为负值,而是因为这个负值的大小和所在位置需要特别要求才可应用&&求得正确结果。

    但我们的平时所遇到的是一般情况下的,是需要算法有通用性的,所以就要求所有边的权重都为正值。

    在本文我此算法的后面部分我会给出两个例子,分别为   不可以有负边 和 可以有负边的例子。为什么在此不先给出呢?  

    Why?????

    如果还不知道Dijkstra算法又怎么会 看懂这两个例子呢?  So  看完这个算法 再看例子吧。

    Dijkstra算法在运行过程中维持的关键信息是一组结点集合S。从源结点s到该集合中每个结点之间的最短路径都已经被找到。算法重复从结点集V-S中选择最短路径估计最小的结点u,讲u加入到    集合S,然后对所有从u发出的边进行松弛。

    Dijkstra 算法如下://这个描述使用的最小优先队列Q来保存结点集合,每个结点的关键值为其d值。

    1   对图的建立和处理,dis[N]数组的初始化等等操作

    2    S = 

    3    Q = G.V

    4  while Q ≠ ∅

    5    u = EXTRACT-MIN(Q)

    6    S = S ∪ {u}

    7     for each vertex v∈ G.Adj[u]

    8                relax(u,v,w)

    此算法在此分为二步 : 第二大步中又分为3小步

    1)   第1~3行 对dis[N]数组等的初始化,集合S 为∅,Q集合为G.V操作

    2)   第4~8行 ① 第4行 进行G.V次操作

           ② 第5~行 从Q中找到一个点,这个点是Q中所有的点   s—>某点  最小的最短路径的点,并将此点加入S集合

           ③ 第7~8行  进行松弛操作,用此点来更新其他路径的距离。

    对于邻接矩阵存储的图 来说此算法的时间复杂度为 O(|V|²),用其他的数据结构可以优化为O(|E|log|V|)的时间复杂度。

    对于本文所说的其他数据结构 使用的为前向星,对于前向星是不能出现负边的。

    我们先看邻接矩阵存储的图的情况。

还是hdu的那道题  http://acm.hdu.edu.cn/showproblem.php?pid=1874

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define MAX 9999999

using namespace std;

int G[203][203];//二维数组 图的存储
int n, s, t;//n 点的个数 , s 起点 ,t 终点

void dijkstra()
{
    bool vis[203];//相当于集合Q的功能, 标记该点是否访问过
    int dis[203];//保存最短路径
    int i, j, k;

    for(i=0;i<n;i++)//初始化
        dis[i] = G[s][i];//s—>各个点的距离
    memset(vis,false,sizeof(vis));//初始化为假 表示未访问过
    dis[s] = 0;//s->s 距离为0
    vis[s] = true;//s点访问过了,标记为真
    for(i=1;i<n;i++)//G.V-1次操作+上面对s的访问 = G.V次操作
    {
        k = -1;
        for(j=0;j<n;j++)//从尚未访问过的点中选一个距离最小的点
            if(!vis[j] && (k==-1||dis[k]>dis[j]))//未访问过 && 是距离最小的
                k = j;
        if(k == -1)//若图是不连通的则提前结束
            break;//跳出循环
        vis[k] = true;//将k点标记为访问过了
        for(j=0;j<n;j++)//松弛操作
            if(!vis[j] && dis[j]>dis[k]+G[k][j])//该点为访问过 && 可以进行松弛
                dis[j] = dis[k]+G[k][j];//j点的距离  大于当前点的距离+w(k,j) 则松弛成功,进行更新
    }
    printf("%d\n",dis[t]==MAX?-1:dis[t]);//输出结果
}

int main()
{
    int m, i, j, u, v, w;

    while(scanf("%d %d",&n,&m)==2){//获取点的个数 边的个数
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                G[i][j] = i==j?0:MAX;//初始化,本身到本身的距离为0,其他的为无穷大
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//获取u,v,w(u,v);
            if(G[u][v]>w)//因为初始化的操作  && 若有重边要去最小的权重值
                G[u][v] = G[v][u] = w;//无向图 双向
        }
        scanf("%d %d",&s,&t);//获取起止点
        dijkstra();
    }
    return 0;
}


应用的数据结构

int G[203][203];//二维数组 图的存储


主函数对数据的获取


int main()
{
    int m, i, j, u, v, w;

    while(scanf("%d %d",&n,&m)==2){//获取点的个数 边的个数
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                G[i][j] = i==j?0:MAX;//初始化,本身到本身的距离为0,其他的为无穷大
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//获取u,v,w(u,v);
            if(G[u][v]>w)//因为初始化的操作  && 若有重边要去最小的权重值
                G[u][v] = G[v][u] = w;//无向图 双向
        }
        scanf("%d %d",&s,&t);//获取起止点
        dijkstra();
    }
    return 0;
}


Dijkstra算法


void dijkstra()
{
    bool vis[203];//相当于集合Q的功能, 标记该点是否访问过
    int dis[203];//保存最短路径
    int i, j, k;

    for(i=0;i<n;i++)//初始化
        dis[i] = G[s][i];//s—>各个点的距离
    memset(vis,false,sizeof(vis));//初始化为假 表示未访问过
    dis[s] = 0;//s->s 距离为0
    vis[s] = true;//s点访问过了,标记为真
    for(i=1;i<n;i++)//G.V-1次操作+上面对s的访问 = G.V次操作
    {
        k = -1;
        for(j=0;j<n;j++)//从尚未访问过的点中选一个距离最小的点
            if(!vis[j] && (k==-1||dis[k]>dis[j]))//未访问过 && 是距离最小的
                k = j;
        if(k == -1)//若图是不连通的则提前结束
            break;//跳出循环
        vis[k] = true;//将k点标记为访问过了
        for(j=0;j<n;j++)//松弛操作
            if(!vis[j] && dis[j]>dis[k]+G[k][j])//该点为访问过 && 可以进行松弛
                dis[j] = dis[k]+G[k][j];//j点的距离  大于当前点的距离+w(k,j) 则松弛成功,进行更新
    }
    printf("%d\n",dis[t]==MAX?-1:dis[t]);//输出结果
}

另一种 用其他的数据结构可以优化为O(|E|log|V|)的时间复杂度。

    使用STL中的最小优先队列 priority_queue,进行优化。

     题目继续使用此题。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define MAX 9999999

using namespace std;
//pair 的first 保存的为最短距离, second保存的为顶点编号
typedef pair<int, int >P;//对组  不知道请自行百度   

struct node
{
    int v, w;//v 为到达的点, w为权重
    int next;//记录下一个结构体的位置 ,就向链表的next功能是一样的
};
node edge[2003];//存所有的边,因为是无向图,所以*2
int cnt;//结构体的下标
int n, s, t;//n 点数,s 起点,t止点
int head[203];//和链表的头指针数组是一样的。只不过此处head[u]记录的为最后加入 edge 的且与u相连的边在 edge 中的位置,即下标

void add(int u, int v, int w)//加边操作
{
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];//获得下一个结构体的位置
    head[u] = cnt++;//记录头指针的下标
}

void dijkstra()
{
    int dis[203];//最短路径数组
    int i, v;//v保存从队列中取出的数的第二个数  也就是顶点的编号
    priority_queue<P,vector<P>,greater<P> >que;//优先队列 从小到大
    node e;//保存边的信息,为了书写方便
    P p;//保存从队列取出的数值

    fill(dis,dis+n,MAX);//初始化,都为无穷大
    dis[s] = 0;//s—>s  距离为0
    que.push(P(0,s));//放入距离 为0   点为s
    while(!que.empty()){
        p = que.top();//取出队列中最短距离最小的对组
        que.pop();//删除
        v = p.second;//获得最短距离最小的顶点编号
        if(dis[v] < p.first)//若取出的不是最短距离
            continue;//则进行下一次循环
        for(i=head[v];i!=-1;i=edge[i].next)//对与此点相连的所有的点进行遍历
        {
            e = edge[i];//为了书写的方便。
            if(dis[e.v]>dis[v]+e.w){//进行松弛
                dis[e.v]=dis[v]+e.w;//松弛成功
                que.push(P(dis[e.v],e.v));//讲找到的松弛成功的距离 和顶点放入队列
            }
        }
    }
    printf("%d\n",dis[t]==MAX?-1:dis[t]);//输出结果
}

int main()
{
    int m, u, v, w;

    while(scanf("%d %d",&n,&m)==2){//获取点数  边数
        cnt = 0;//结构体下标从0开始
        memset(head,-1,sizeof(head));//初始化head[N]数组
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//获取u,v,w(u,v)
            add(u,v,w);//加边
            add(v,u,w);//加边
        }
        scanf("%d %d",&s,&t);//获取起止点
        dijkstra();
    }
    return 0;
}

 用到的数据结构 :前向星 对组 优先队列

//pair 的first 保存的为最短距离, second保存的为顶点编号
typedef pair<int, int >P;//对组  不知道请自行百度   

struct node//前向星存边
{
    int v, w;//v 为到达的点, w为权重
    int next;//记录下一个结构体的位置 ,就向链表的next功能是一样的
};
node edge[2003];//存所有的边,因为是无向图,所以*2
int head[203];//和链表的头指针数组是一样的。只不过此处head[u]记录的为最后加入 edge 的且与u相连的边在 edge 中的位置,即下标

priority_queue<P,vector<P>,greater<P> >que;//优先队列 从小到大



 在此我们说一下前向星的加边函数

void add(int u, int v, int w)//加边操作
{
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];//获得下一个结构体的位置
    head[u] = cnt++;//记录头指针的下标
}


主函数对数据的获取

int main()
{
    int m, u, v, w;

    while(scanf("%d %d",&n,&m)==2){//获取点数  边数
        cnt = 0;//结构体下标从0开始
        memset(head,-1,sizeof(head));//初始化head[N]数组
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//获取u,v,w(u,v)
            add(u,v,w);//加边
            add(v,u,w);//加边
        }
        scanf("%d %d",&s,&t);//获取起止点
        dijkstra();
    }
    return 0;
}


 Dijkstra算法求值

void dijkstra()
{
    int dis[203];//最短路径数组
    int i, v;//v保存从队列中取出的数的第二个数  也就是顶点的编号
    priority_queue<P,vector<P>,greater<P> >que;//优先队列 从小到大
    node e;//保存边的信息,为了书写方便
    P p;//保存从队列取出的数值

    fill(dis,dis+n,MAX);//初始化,都为无穷大
    dis[s] = 0;//s—>s  距离为0
    que.push(P(0,s));//放入距离 为0   点为s
    while(!que.empty()){
        p = que.top();//取出队列中最短距离最小的对组
        que.pop();//删除
        v = p.second;//获得最短距离最小的顶点编号
        if(dis[v] < p.first)//若取出的不是最短距离
            continue;//则进行下一次循环
        for(i=head[v];i!=-1;i=edge[i].next)//对与此点相连的所有的点进行遍历
        {
            e = edge[i];//为了书写的方便。
            if(dis[e.v]>dis[v]+e.w){//进行松弛
                dis[e.v]=dis[v]+e.w;//松弛成功
                que.push(P(dis[e.v],e.v));//讲找到的松弛成功的距离 和顶点放入队列
            }
        }
    }
    printf("%d\n",dis[t]==MAX?-1:dis[t]);//输出结果
}

自此Dijkstra算法就算接近尾声了,现在还大家一个债,那就是前面的Why

 在此给出的是百度知道上的一位网友给的解释 :

    dijkstra由于是贪心的,每次都找一个距源点最近的点(dmin),然后将该距离定为这个点到源点的最短路径(d[i]<--dmin);但如果存在负权边,那就有可能先通过并不是距源点最近的一个次优点(dmin'),再通过这个负权边L(L<0),使得路径之和更小(dmin'+L<dmin),则dmin'+L成为最短路径,并不是dmin,这样dijkstra就被囧掉了

  比如n=3,邻接矩阵:

  0,3,4

  3,0,-2

  4,-2,  0

 用dijkstra求得d[1,2]=3,事实上d[1,2]=2,就是通过了1-3-2使得路径减小。
 这就是为什么Dijkstra不能处理负边的情况。

 再给出可以使用Dijkstra && 带负边的情况
 n = 3,邻接矩阵
 0, 3, 4
 3, 0, -1
 4, -1, 0
 dis[1,2] = 3, dis[1,3] = 2 是正确的。(为邻接矩阵的存图方式下的)
 
 此算法讲解结束。

  
3、floyd-Warshall算法 :   (动态规划)
  
  floyd算法是一个很强大的算法,它可以计算任意两点之间的最短路径,其边可以为负值。
  对于floyd算法是我刚刚开始接触最短路算法中最喜欢的了,因为它的代码简短,便于理解,而且功能也很强大,虽然有点短腿但我还是很喜欢这个代码。
  floyd算法是三重for 的嵌套。对于这个算法给出《挑战程序设计》中的证明 :
证明:
  对于0~k,我们分i到j的最短路正好经过顶点k一次和完全不经过顶点k两种情况来讨论。不仅过顶点k的情况下,d[k][i][j] = d[k-1][i][j]。通过顶点k的情况,d[k][i][j]
  = d[k-1][i][k]+d[k-1][k][j]。合起来就得到了d[k][i][j] = min(d[k-1][i][j],d[k-1][i][k]+d[k-1][k][j])。这个DP也可以用同一个数组不断进行如下的操作:
  d[i][j] = min(d[i][j],d[i][k]+d[k][j])的更新来实现。
  floyd算法的时间复杂度为O(|V|³)。 450*450*450<10的8次方
  下面给出floyd算法的程序.
void floyd()
{
    int i, j, k;

    for(k=0;k<n;k++)
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                G[i][j] = min(G[i][j],G[i][k]+G[k][j]);
    printf("%d\n",G[s][t]==MAX?-1:G[s][t]);
}              
在此给出图的初始化和数据的读取。
<pre class="html" name="code">int main()
{
    int i, j, m, u, v, w;

    while(scanf("%d %d",&n,&m)==2){
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                G[i][j] = i==j?0:MAX;
        while(m--){
            scanf("%d %d %d",&u,&v,&w);
            if(G[u][v]>w)
                G[u][v] = G[v][u] = w;
        }
        scanf("%d %d",&s,&t);
        floyd();
    }
    return 0;
}

对floyd算法呢,因为他的简洁,在此就不多说。

    补充一下:对于floyd判断负环是否存在只需检查是否存在d[i][i]是负数的顶点i 即可。

    

4、 SPFA算法   (bellman-ford算法的优化)

    SPFA算法是西南交通大学段凡丁于1994年发表的。

    SPFA算法 :设立一个先进先出的队列用来保存待优化的结点,优化时每次取出队首结点u,并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作,如果v点的最短    路径估计值有所调整,且v点不在当前的队列中,就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作,直至队列空为止。

    SPFA 是这样判断负环的: 如果某个点进入队列的次数超过N次则存在负环(SPFA无法处理带负环的图)

     期望的时间复杂度:O(ke), 其中k为所有顶点进队的平均次数,可以证明k一般小于等于2。

    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算法。

    SPFA() :

    1   对图的建立和处理,dis[N]数组的初始化等等操作

    2   Q += s //Q 为一个队列  s为源点

    3   while Q ≠ ∅//队列不为空

    4    u = Q中的点//从Q中取出一个点u

    5   把u点标记为为访问过的

    6    for each vertex v∈ G.Adj[u]//对所有的边

    7        relax(u,v,w)//进行松弛

    8                  if(v  未被访问过)//若v未被访问过

    9            Q += v;//加入队列

    以上伪代码为自己写的,希望能看。

    此算法分为3部分 :

    1)  第1~2行  建图对dis[N]和vis[N]数组等数组进行初始化。 若判断负环需要加一个flag[N]数组,初始化为0,某点 u 若加入Q队列一次,怎flag[u]++,若flag[u]>=n,说明u进入队列的次数大于点的个数,因此此图存在负环,返回一个布尔值。

      2)  第3行当队列不为空的时候进行操作

     3)  第4~9行 取出Q中的点u ,用u对所有的边进行松弛操作,若松弛成功,判断该点v是否被访问过,若未访问过加入Q队列中。

    继续以poj的虫洞为例题

http://poj.org/problem?id=3259

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define MAX 9999999

using namespace std;

int G[503][503];
int n;

bool SPFA()
{
    int u;
    int i;
    queue<int >que;
    int dis[503];
    bool vis[503];
    int flag[503];

    memset(flag,0,sizeof(flag));
    memset(vis,false,sizeof(vis));
    fill(dis,dis+n+1,MAX);
    dis[1] = 0;
    que.push(1);
    while(!que.empty()){
        u = que.front();
        que.pop();
        vis[u] = false;
        for(i=1;i<=n;i++)
        {
            if(dis[i]>dis[u]+G[u][i]){
                dis[i] = dis[u]+G[u][i];
                if(!vis[i]){
                    vis[i] = true;
                    flag[i]++;
                    if(flag[i]>=n)
                        return true;
                    que.push(i);
                }
            }
        }
    }
    return false;
}

int main()
{
    int t, k, i, j, u, v, w, m;

    scanf("%d",&t);
    while(t--){
        scanf("%d %d %d",&n,&m,&k);
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                G[i][j] = i==j?0:MAX;
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            if(G[u][v]>w)
                G[u][v] = G[v][u] = w;
        }
        for(i=0;i<k;i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            G[u][v] = -w;
        }
        printf("%s\n",SPFA()?"YES":"NO");
    }
    return 0;
}

SPFA算法



bool SPFA()
{
    int u;//从队列Q中取出的数
    int i;
    queue<int >que;//Q队列
    int dis[503];//保存最短距离
    bool vis[503];//访问数组
    int flag[503];//记录点进入队列的次数

    memset(flag,0,sizeof(flag));//初始化为0
    memset(vis,false,sizeof(vis));//初始化
    fill(dis,dis+n+1,MAX);//初始化
    dis[1] = 0;//从  1 开始
    que.push(1);//将 1 放入队列
    while(!que.empty()){//Q 不为空
        u = que.front();//从Q中取出一个数
        que.pop();//删除此数
        vis[u] = false;//标记为未访问过
        for(i=1;i<=n;i++)//对所有的边
        {
            if(dis[i]>dis[u]+G[u][i]){//进行松弛
                dis[i] = dis[u]+G[u][i];//松弛成功
                if(!vis[i]){//若点i 未被访问过
                    vis[i] = true;//标记为访问过
                    flag[i]++;//入队列次数+1
                    if(flag[i]>=n)//若此点进入队列此数超过n次  说明有负环
                        return true;//有负环
                    que.push(i);//将 此点放入队列
                }
            }
        }
    }
    return false;//没有负环
}

SPFA算法对于稀疏图才能发挥它的大作用,对于稀疏图我们用到的数据结构为  前向星

    下面就是 SPFA+前向星的程序  并应用了SLF  双向队列进行优化

</pre></p><p></p><pre class="html" name="code">#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define MAX 9999999

using namespace std;

struct node//前向星
{
    int v,w;//v 终点,w 权值
    int next;//下一个
};
node edge[5203];//前向星
int head[503];//头指针式的数组
int cnt;//下标
int n;//点的个数

void add(int u, int v, int w)//加边  建议 若看不懂前向星 请自己动手画一下 按照给出的数据和程序
{
    edge[cnt].v = v;//
    edge[cnt].w = w;//
    edge[cnt].next = head[u];//
    head[u] = cnt++;//
}

bool SPFA()
{
    int i, u, v;//u 从Q中取出的点  v找到的点
    int dis[503];//保存最短路径
    int flag[503];//保存某点加入队列的次数
    bool vis[503];//标记数组
    deque<int>que;//双向队列  自己百度

    fill(dis,dis+n+1,MAX);//初始化
    memset(flag,0,sizeof(flag));//初始化
    memset(vis,false,sizeof(vis));//初始化
    dis[1] = 0;// s为1
    que.push_back(1);//将s = 1 加入队列
    while(!que.empty()){//当队列不为空
        u = que.front();//从队列中取出一个数
        que.pop_front();//删除
        vis[u] = false;//标记为未访问
        for(i=head[u];i!=-1;i=edge[i].next)//对所有与该边相连的边进行查找
        {
            v = edge[i].v;//保存点 便于操作
            if(dis[v]>dis[u]+edge[i].w){//进行松弛操作
                dis[v] = dis[u]+edge[i].w;//松弛成功
                if(!vis[v]){//若该点未被标记
                    vis[v] = true;//标记为真
                    flag[v]++;//该点入队列次数++
                    if(flag[v]>=n)//若该点进入队列次数超过n次 说明有负环
                        return true;//返回有负环
                    //一下为SLF优化
                    if(!que.empty() && dis[v]<dis[que.front()])//若为队列不为空 && 队列第一个点的最短距离大于当前点的最短距离
                        que.push_front(v);//将该点放到队首
                    else//不然
                        que.push_back(v);//放入队尾
                }
            }
        }
    }
    return false;//没有负环
}

int main()
{
    int u, v, w, m, k, t;
    
    scanf("%d",&t);//获取测试数据
    while(t--){
        memset(head,-1,sizeof(head));//初始化
        cnt = 0;//下标为0  初始化
        scanf("%d %d %d",&n,&m,&k);//获取点的个数 ,正边的个数, 负边的个数
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//正边获取
            add(u,v,w);//无向图
            add(v,u,w);//双向建图
        }
        while(k--){
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,-w);//单向图
        }
        printf("%s\n",SPFA()?"YES":"NO");//输出结果
    }
    return 0;
}
所用数据结构有 前向星  双向队列
struct node//前向星
{
    int v,w;//v 终点,w 权值
    int next;//下一个
};
node edge[5203];//前向星
int head[503];//头指针式的数组
int cnt;//下标

 deque<int>que;//双向队列  自己百度
主函数 对数据的获取 和图的建立
int main()
{
    int u, v, w, m, k, t;
    
    scanf("%d",&t);//获取测试数据
    while(t--){
        memset(head,-1,sizeof(head));//初始化
        cnt = 0;//下标为0  初始化
        scanf("%d %d %d",&n,&m,&k);//获取点的个数 ,正边的个数, 负边的个数
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//正边获取
            add(u,v,w);//无向图
            add(v,u,w);//双向建图
        }
        while(k--){
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,-w);//单向图
        }
        printf("%s\n",SPFA()?"YES":"NO");//输出结果
    }
    return 0;
}
 SPFA+前向星  
</pre><pre class="html" name="code"><pre class="html" name="code">bool SPFA()
{
    int i, u, v;//u 从Q中取出的点  v找到的点
    int dis[503];//保存最短路径
    int flag[503];//保存某点加入队列的次数
    bool vis[503];//标记数组
    deque<int>que;//双向队列  自己百度

    fill(dis,dis+n+1,MAX);//初始化
    memset(flag,0,sizeof(flag));//初始化
    memset(vis,false,sizeof(vis));//初始化
    dis[1] = 0;// s为1
    que.push_back(1);//将s = 1 加入队列
    while(!que.empty()){//当队列不为空
        u = que.front();//从队列中取出一个数
        que.pop_front();//删除
        vis[u] = false;//标记为未访问
        for(i=head[u];i!=-1;i=edge[i].next)//对所有与该边相连的边进行查找
        {
            v = edge[i].v;//保存点 便于操作
            if(dis[v]>dis[u]+edge[i].w){//进行松弛操作
                dis[v] = dis[u]+edge[i].w;//松弛成功
                if(!vis[v]){//若该点未被标记
                    vis[v] = true;//标记为真
                    flag[v]++;//该点入队列次数++
                    if(flag[v]>=n)//若该点进入队列次数超过n次 说明有负环
                        return true;//返回有负环
                    //一下为SLF优化
                    if(!que.empty() && dis[v]<dis[que.front()])//若为队列不为空 && 队列第一个点的最短距离大于当前点的最短距离
                        que.push_front(v);//将该点放到队首
                    else//不然
                        que.push_back(v);//放入队尾
                }
            }
        }
    }
    return false;//没有负环
}

 好了,四种算法已经讲完。 

   

5、 BFS 求解最短路

    在我们学习图的基本算法BFS 和DFS的时候,其实那就是一个求解每一步的权重都为1的最短路,那么权重不为1的情况我,我们是否继续使用呢?

    答案是肯定的。

    采用邻接表或前向星进行图的存储 , 则BFS的时间复杂度为   开始的初始化O(V)+BFS操作O(E) = O (V+E)

    继续以hdu 的  http://acm.hdu.edu.cn/showproblem.php?pid=1874


#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

struct P
{
    int v, w;//v 顶点 w 最短距离
    bool operator <(const P &a)const{
        return a.w < w;//按w  从小到大排序
    }
};
struct node//前向星
{
    int v, w;//v 顶点  w权重
    int next;//下一个位置
};
node edge[2003];
int head[203];//头指针数组
int cnt, s, t;// cnt 下标

void add(int u, int v, int w)//加边操作
{
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

void BFS()
{
    priority_queue<P>que;//优先队列   按w从小到大
    bool vis[203];//标记数组, 标记是否被访问过
    P p, q;
    int i, v;

    memset(vis,false,sizeof(vis));//初始化
    p.v = s;//顶点为 s
    p.w = 0;//距离为 0
    que.push(p);//放入队列
    while(que.empty() == false){//队列不为空
        p = que.top();//取出队列的队首
        que.pop();//删除
        if(p.v == t){//若找到终点
            printf("%d\n",p.w);//输出结果
            return ;//返回
        }
        vis[p.v] = true;//此点标记为访问过
        for(i=head[p.v];i!=-1;i=edge[i].next)//查找与该点相连的点
        {
            v = edge[i].v;
            if(vis[v] == false){//若点未被访问过
                q.v = v;//存入结构体
                q.w = p.w+edge[i].w;//距离更新
                que.push(q);//放入队列
            }
        }
    }
    printf("-1\n");//若没有到达终点  输出-1
}

int main()
{
    int m, u, v, w, n;

    while(scanf("%d %d",&n,&m)==2){//获取点的个数  边的个数
        memset(head,-1,sizeof(head));//初始化
        cnt = 0;//初始化
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//获取u,v,w
            add(u,v,w);//加边
            add(v,u,w);//无向图   双向加边
        }
        scanf("%d %d",&s,&t);//获取起止点
        BFS();
    }
    return 0;
}
</pre></p><p></p><pre class="html" name="code">所用数据结构   前向星  优先队列
</pre><pre class="html" name="code">struct P
{
    int v, w;//v 顶点 w 最短距离
    bool operator <(const P &a)const{
        return a.w < w;//按w  从小到大排序
    }
};
priority_queue<P>que;//优先队列   按w从小到大
struct node//前向星
{
    int v, w;//v 顶点  w权重
    int next;//下一个位置
};
node edge[2003];
int head[203];//头指针数组
主函数对数据的获取
</pre><pre class="html" name="code">int main()
{
    int m, u, v, w, n;

    while(scanf("%d %d",&n,&m)==2){//获取点的个数  边的个数
        memset(head,-1,sizeof(head));//初始化
        cnt = 0;//初始化
        while(m--){
            scanf("%d %d %d",&u,&v,&w);//获取u,v,w
            add(u,v,w);//加边
            add(v,u,w);//无向图   双向加边
        }
        scanf("%d %d",&s,&t);//获取起止点
        BFS();
    }
    return 0;
}
加边操作
</pre><pre class="html" name="code"><pre class="html" name="code">void add(int u, int v, int w)//加边操作
{
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}


BFS

void BFS()
{
    priority_queue<P>que;//优先队列   按w从小到大
    bool vis[203];//标记数组, 标记是否被访问过
    P p, q;
    int i, v;

    memset(vis,false,sizeof(vis));//初始化
    p.v = s;//顶点为 s
    p.w = 0;//距离为 0
    que.push(p);//放入队列
    while(que.empty() == false){//队列不为空
        p = que.top();//取出队列的队首
        que.pop();//删除
        if(p.v == t){//若找到终点
            printf("%d\n",p.w);//输出结果
            return ;//返回
        }
        vis[p.v] = true;//此点标记为访问过
        for(i=head[p.v];i!=-1;i=edge[i].next)//查找与该点相连的点
        {
            v = edge[i].v;
            if(vis[v] == false){//若点未被访问过
                q.v = v;//存入结构体
                q.w = p.w+edge[i].w;//距离更新
                que.push(q);//放入队列
            }
        }
    }
    printf("-1\n");//若没有到达终点  输出-1
}

6、 路径还原  

    路径还原我们一般用不到,但是一般用不到,我们既然学了那么多最短路的算法,会还原一下,那不是锦上添花吗?

    所以 学!!!

    路径还原问题   在线题库中我没有发现。 这里就给出一组测试数据然后给出算法 就结束了。

    在此 用Dijkstra算法 演示路径还原 其他的bellman-ford算法 和floyd-Warshall算法都可用类似方法进行最短路的还原。

    第1行 两个数 n 和 m

    第2~m+1行  给出 u,v,w

    第m+2 行  给出两个数 s 和 t  

    求出 s—>t 的最短路  和 路径 

    前提 这个图是连通的。s—>t 的最短路是存在的。

    输入 :

    3 3

    0 1 1

    0 2 3

    1 2 1

    0 2

    输出:

    2(最短路)

    2—>1—>0(路径)

    在本文开始说松弛操作的时候  就说过在《算法导论》中,松弛操作还有一个记录路径的操作就 是这个了。


1 if(dis[i]>dis[k]+G[k][i]){//在松弛操作中
2     dis[i] = dis[k]+G[k][i];//不仅更新距离
3     pre[i] = k;//同时记录路径
4 }

是这个样子。

    下面给出程序 :


#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define INF 999999
using namespace std;

int G[203][203];
int n, s, t;

bool Dijkstra()
{
    int i, j, k;
    int dis[203];
    bool vis[203];
    int pre[203];//记录路径

    memset(vis,false,sizeof(vis));
    fill(dis,dis+n,INF);
    memset(pre,-1,sizeof(pre));//初始化为-1
    dis[s] = 0;
    for(i=0;i<n;i++)
    {
        k = -1;
        for(j=0;j<n;j++)
            if(vis[j] == false && (k == -1 || dis[k]>dis[j]))
                k = j;
        if(k == -1)
            break;
        vis[k] = true;
        for(j=0;j<n;j++)
            if(vis[j] == false && dis[j]>dis[k]+G[k][j]){
                dis[j] = dis[k]+G[k][j];
                pre[j] = k;//在松弛操作中更新边的同时  记录路径
            }
    }
    printf("s——>t  的最短路为 :");
    printf("%d\n",dis[t]);
    printf("路径为 :");
    //一下部分为路径的还原
    queue<int >que;//申请一个队列
    for(t;t!=-1;t=pre[t])//从t 一直寻找到s
        que.push(t);//放入队列
    printf("%d",que.front());//输出第一个
    que.pop();//删除
    while(!que.empty()){//队列不为空
        printf("——>%d",que.front());//输出
        que.pop();//删除
    }
}

int main()
{
    int i, j, u, v, w, m;

    while(scanf("%d %d",&n,&m)==2){
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                G[i][j] = i==j?0:INF;
        while(m--){
            scanf("%d %d %d",&u,&v,&w);
            if(G[u][v]>w)
                G[u][v] = G[v][u] = w;
        }
        scanf("%d %d",&s,&t);
        Dijkstra();
    }
    return 0;
}


参考资料  :  1 《算法导论》 第三版

       2 《挑战程序设计》第2版

       3  百度百科

       4  维基百科




发布了608 篇原创文章 · 获赞 5959 · 访问量 92万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 酷酷鲨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览