Dijkstra算法小结

Dijkstra算法应该是图论里最基础的了，它所能解决的问题就是最短路之类的，它的核心内容就是“松弛操作”，这在算法导论这本书中有详细的介绍。给你一幅图，给定起点和终点，求起点到终点的最短距离，这就是最短路问题，不论图是有向还是无向，都可以用Dijkstra来解决。

举个例子，给你一幅图，要你求七点到终点的距离，你会怎么做？枚举出所有路径？？？这个理论可行，但是当这幅图比较复杂时，应该会比较吃力，而且会超时。这是dijkstra就派上用场了，首先我们定义两个数组，一个二维的的d[i][j],代表从i点到j点的距离，也就是两点的边权。当两点不是直接相连时，应该初始为一个较大的数inf=10000000，如果是的d[i][i]我们可以赋值为0。第二个数组是f[i]，它的定义是从起点到i点的最短距离，我们设终点为N，那么的d[N]是不是就是起点到N点的最短距离。好了，现在大致思路有了，问题就在于如何去求d[i]呢？？

首先我们是不是可以想到起点到起点的最短距离是0，假设起点的下标为1，也就是说d[1]=0、、、然后除起点以外的点d[i]设为一个较大的数inf，之后我们是不不是可以用起点来更新周围与它直接相连的点，状态转移方程是min(f[j],f[i]+d[i][j]),这个转换是什么意思呢，就是说i与j是直接相连的点，f[i]是起点到i的最短距离，那么f[j]是不是f[i]+d[i][j]（边权）与当前f[j]的最小值。而在开始我们定义的f[1]=0，f[j]=inf,(一个很大的数），那么与1直接相连的点是不是一定会被更新，当我们更新完第一步是，那之后的是不是也能继续呗更新。

现在问题就是说当起点更新完它周围的点时，起点f[1]是不能再被更新了，因为它在更新之前就是最小的了，它周围的点势必无法更新它，所以说，这个点是可以被删除了，在之后的操作中它已经无效了。如何删除能，我们可以在定义一个数组k[i],当然你也可以定义一个bool型数组，true表示未被删除，false表示已删除，本人比较喜欢用1、0来表示。那么现在我们应该找那个点来更新周围的点呢？？、、、、仔细考虑后是不是剩下的点中f[j]最小的点？？？为什么呢？？？你想，它在当前已经是最小的了，周围的点都比它大，加上两点之间的边权肯定比它大，也就是说它不可能再被更新了，但它可以用来更新周围的点，更新完之后删除，这样直到更新完所有点。最短路也就求出来了。

看一道hdu上的例子吧，正宗的最短路。http://acm.hdu.edu.cn/showproblem.php?pid=2544

附上代码

#include<stdio.h>
#include<string.h>
int d[112][112];//两点间的距离，本题中此数组可以不初始化。
int main()
{
    int N,M;
    while(scanf("%d%d",&N,&M)!=EOF&&(N!=0||M!=0))
    {
        int i,j,f[112],k[112],t;
        memset(d,0,sizeof(d));
        memset(k,0,sizeof(k));
        for(i=1;i<=M;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            scanf("%d",&d[a][b]);// 读入数据
            d[b][a]=d[a][b];//无向图的构图
        }
        f[1]=0;//起点
        for(i=2;i<=N;i++)
            f[i]=9999999;//初始化
        int p=1;        
        
        while(1)
        {
            int judge=-1;
            for(t=1;t<=N;t++)
                if(k[t]==0)
                {
                    if(judge==-1||f[judge]>f[t])
                    judge=t;//寻找最小的那个点
                }
            
            if(judge==-1)
                break;
            for(j=1;j<=N;j++)
                if(d[judge][j]>0&&f[j]>f[judge]+d[judge][j])//更新周围的点，也就是松弛操作
                    f[j]=f[judge]+d[judge][j];
                k[judge]=1;//删除操作
    
        }
        printf("%d\n",f[N]);
        //for(i=1;i<=N;i++)
        //    printf("%d ",f[i]);
        
    }
    
    return 0;
}

/*
7 10
1 2 2
1 3 5
2 3 4
2 4 6
2 5 10
3 4 2
4 6 1
5 6 3
5 7 5
6 7 9    16
*/

接下来几天如果有空也会陆续上传一些最短路的题目及代码，与大家一起交流