HDU 1874 （最短路）Floyd-->>Dijk…

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1874

这题比较基础，拿来练各种刚学会的算法比较好，可以避免好多陷阱，典型的最短路模板题

 

第一种解法：Floyd算法

 

算法实现：

使用一个邻接矩阵存储边权值，两两之间能访问的必为一个有限的数，不能访问则为无穷大（用2^29代替）。注意自身和自身距离为0。

对于一对顶点 u 和 v，看看是否存在一个断点 w 使得从 u 经过 w 到 v 比已知的路径更短（包含原始输入中从 u 直接到 v 的路程）。

对所有顶点进行如上松弛操作，得到的结果是两点之间的最短路程，也可判断两点是否连通。

算法缺点：

普通的Floyd算法时间复杂度为O(n^3)，对于数据较多的情况容易TLE。但解决本题 HDU 1874 完全足够。

 

Floyd算法耗时62MS

 

C语言: 高亮代码由发芽网提供

#include
#define Max 0xfffffff
int n , m , map [ 201 ][ 201 ];
int min( int a , int b)
{
    return a >b ?b : a;
}
void getmap()
{
    int i , j , a ,b , l;
    for( i = 0; i <n; i ++)
        for( j = 0; j <n; j ++)
            map [ i ][ j ] =( i == j ? 0 : Max);
    for( i = 0; i < m; i ++)
    {
        scanf( "%d%d%d" , & a , &b , & l);
        map [ a ][b ] = map [b ][ a ] = min( map [ a ][b ], l);
    }
}
void floyd( int s , int e)
{
    int i , j , k;
    for( k = 0; k <n; k ++)
        for( i = 0; i <n; i ++)
            for( j = 0; j <n; j ++)
                map [ i ][ j ] = min( map [ i ][ j ], map [ i ][ k ] + map [ k ][ j ]);
            printf( "%d \n " , map [s ][ e ] < Max ? map [s ][ e ] :- 1);
}
int main()
{
    int s , e;
    while( ~ scanf( "%d%d" , &n , & m))
    {
        getmap();
        scanf( "%d%d" , &s , & e);
        floyd(s , e);
    }
    return 0;
}

第二种解法： Dijkstra算法

 

这个算法比较经典，一般的最短路径都可以用这个来解决，耗时也比较少，不过不能处理负权路径

按路径长度递增次序产生最短路径算法：

　　把V分成两组：

　　（1）S：已求出最短路径的顶点的集合

　　（2）V-S=T：尚未确定最短路径的顶点集合

　　将T中顶点按最短路径递增的次序加入到S中，

　　保证：（1）从源点V0到S中各顶点的最短路径长度都不大于

　　从V0到T中任何顶点的最短路径长度

　　（2）每个顶点对应一个距离值

　　S中顶点：从V0到此顶点的最短路径长度

　　T中顶点：从V0到此顶点的只包括S中顶点作中间

　　顶点的最短路径长度

　　依据：可以证明V0到T中顶点Vk的最短路径，或是从V0到Vk的

　　直接路径的权值；或是从V0经S中顶点到Vk的路径权值之和

　　（反证法可证）

　　 求最短路径步骤

　　算法步骤如下：

　　1. 初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值

　　若存在，d(V0,Vi)为弧上的权值

　　若不存在，d(V0,Vi)为∝

　　2. 从T中选取一个其距离值为最小的顶点W且不在S中，加入S

　　3. 对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的

　　距离值比不加W的路径要短，则修改此距离值

　　重复上述步骤2、3，直到S中包含所有顶点，即S=T为止

 

Dijkstra算法耗时0MS

C语言: 高亮代码由发芽网提供

#include
#include
#define max 999999
int map [ 201 ][ 201 ];
int n , m , st , en , f [ 201 ], mark [ 201 ];
void Dijkstra()
{
    int i , j , k , min;
    memset( mark , 0 , sizeof( mark));
    for( i = 0; i <n; i ++)
        f [ i ] = map [ st ][ i ];
    f [ st ] = 0;
    for( i = 0; i <n; i ++)
    {
        min = max;
        for( j = 0; j <n; j ++)
        {
            if( ! mark [ j ] && f [ j ] < min)
            {
                min = f [ j ];
                k = j;
            }
        }
        if( min == max) break;
        mark [ k ] = 1;
        for( j = 0; j <n; j ++)
            if( ! mark [ j ] && f [ j ] > f [ k ] + map [ k ][ j ])
                f [ j ] = f [ k ] + map [ k ][ j ];
    }
    if( f [ en ] != max) printf( "%d \n " , f [ en ]);
    else printf( "-1 \n ");
}
int main()
{
    int x , y , z , i , j;
    while( scanf( "%d%d" , &n , & m) != EOF)
    {
        for( i = 0; i <=n - 1; i ++)
            for( j = 0; j <=n - 1; j ++)
                map [ i ][ j ] = max;
            for( i = 1; i <= m; i ++)
            {
                scanf( "%d %d %d" , & x , & y , & z);
                if( map [ x ][ y ] > z)
                { map [ x ][ y ] = map [ y ][ x ] = z ;}
            }
            scanf( "%d %d" , & st , & en);
            Dijkstra();
    }
    return 0;
}

第三种解法： Bellman_Ford算法

 

这个算法也比较好理解，就是不断松弛操作，处理含有负权的路径

对有向图G(V,E)，用贝尔曼-福特算法求以V_s为源点的最短路径的过程：

• 建立dist[]、Pred[],且dist[s] = 0,其余赋。Pred[]表示某节点路径上的父节点
• 对，比较dist[V_i] + (V_i,V_j)和dist[V_j],并将小的赋给dist[V_j]，如果修改了dist[V_j]则pred[V_j] = V_i（松弛操作）
• 重复以上操作V − 1次
• 再重复操作一次，如dist[V_j] > dist[V_i] + (V_i,V_j),则此图存在负权环。

伪代码：

C语言: 高亮代码由发芽网提供

For i := 1 to | V |- 1 do //v为顶点数
For 每条边( u , v) ∈ E do   //对每条边进行遍历
  Relax( u , v , w);
For 每条边( u , v) ∈ E do   //判断是否存在负权环
  If dis [ u ] + w < dis [ v ] Then Exit( False)

Bellman_Ford算法耗时15MS，

 

代码：

C语言: 高亮代码由发芽网提供

#include
#define MAX 1047483647

int m ,n , d [ 208 ], start , tar;
struct project {
    int x , y , w;
} map [ 2008 ];

void Bellman_Ford()
{
    int i , j;
    for( i = 0; i <n; i ++) //Init
        d [ i ] = MAX;
    d [ start ] = 0;
    for( i = 0; i <n; i ++)
        for( j = 0; j < 2 * m; j ++)
        {
            if( d [ map [ j ]. x ] > d [ map [ j ]. y ] + map [ j ]. w) //relax x --w--> y
                d [ map [ j ]. x ] = d [ map [ j ]. y ] + map [ j ]. w;
        }
    if( d [ tar ] < MAX)
        printf( "%d \n " , d [ tar ]);
    else printf( "-1 \n ");
}

int main()
{
    int i;
    while( scanf( "%d%d" , &n , & m) != EOF)
    {
        for( i = 0; i < m; i ++)
        {
            scanf( "%d%d%d" , & map [ i ]. x , & map [ i ]. y , & map [ i ]. w); //two way road --->   one way road
            map [ i + m ]. y = map [ i ]. x;
            map [ i + m ]. x = map [ i ]. y;
            map [ i + m ]. w = map [ i ]. w;
        }
        scanf( "%d%d" , & start , & tar);
        Bellman_Ford();
    }
    return 0;
}

第四种解法： SPFA算法

这种算法可以说是Bellman_Ford算法的优化，就是在Bellman_Ford算法的基础上加上队列实现，

SPFA(Shortest Path Faster Algorithm)

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

这个算法，简单的说就是队列优化的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)x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。

优化之后耗时0ＭＳ，

代码：

C语言: 高亮代码由发芽网提供

#include //SPFA 模拟队列实现最短路径
#include
#define INF 100000

int map [ 210 ][ 210 ], flag [ 210 ], Q [ 210 ], d [ 210 ];
int m ,n , start , tar;

void SPFA()
{
    int i , x;
    int front = 0 , rear = 0;
    memset( Q , 0 , sizeof( Q));
    memset( flag , 0 , sizeof( flag));
    for( i = 0; i <n; i ++)
        d [ i ] = INF;
    d [ start ] = 0;
    Q [ rear ] = start;
    rear ++;
    flag [ start ] = 1;
    while( front < rear)
    {
        x = Q [ front ]; //出队列
        front =( front + 1) % 210;
        flag [ x ] = 0;
        for( i = 0; i <n; i ++)
        {
            if( d [ i ] > d [ x ] + map [ x ][ i ])
            {
                d [ i ] = d [ x ] + map [ x ][ i ];
                if( ! flag [ i ])
                {
                    Q [ rear ] = i; //入队列
                    rear =( rear + 1) % 210;
                    flag [ i ] = 1;
                }
            }
        }
    }
    if( d [ tar ] < INF)
        printf( "%d \n " , d [ tar ]);
    else printf( "-1 \n ");
}

int main()
{
    int i , j , a ,b , c;
    while( scanf( "%d%d" , &n , & m) != EOF)
    {
        for( i = 0; i <n; i ++)
            for( j = 0; j <n; j ++)
                map [ i ][ j ] = INF;
        for( i = 0; i < m; i ++)
        {
            scanf( "%d%d%d" , & a , &b , & c);
            if( map [ a ][b ] > c)
            map [ a ][b ] = map [b ][ a ] = c;
        }
        scanf( "%d%d" , & start , & tar);
        SPFA();
    }
    return 0;
}

其实最短路总结就一句话，不断的进行松弛操作，无论是什么解法，都要进行松弛操作，然后找到最短路径