图论之最短路径算法

• dijkstra算法 

　　　　基本思想：某最短路径上的点与源点之间的最短路径必然也在改最短路径之上，采用贪心策略，每次选取当前最短路径即可。

void dijkstra(int n)
{
    int num=1,i;
    int min,pos;
    vis[n]=1;

    while(num<n)//n-1次循环
    {
        min=MaxInt;
        for(i=1; i<n; i++)
            if(vis[i]==0 && dis[i]<min)
            {
                pos=i;
                min=dis[i];
            }
        vis[pos]=1;
        dis[pos]=min;

        for(i=1; i<n; i++)
            if(vis[i]==0 && dis[i]>dis[pos]+map[pos][i])
                dis[i]=min+map[pos][i];//更新权值

        num++;
    }
}

• floyd算法

　　　　基本思想：采用动态规划思想，点i，j之间的最短路径要么包含点k，要么不包含点k，选择最小的即可。

void floyd(int n)
{
    int i,j,k;
    memset(dis,MaxInt,sizeof(dis));

    for(i=1; i<=n; i++)
        for(j=1; j<=n; j++)
            for(k=1; k<=n; k++)
                if(dis[i][j] > dis[i][k]+dis[k][j] )
                    dis[i][j] = dis[i][k]+dis[k][j];
}

• spfa算法

　　　　基本思想：spfa算法是bellman-ford算法的队列实现，用dis数组表示点与源点之间的当前最短距离，用数组vis标记点是否在队列中，初始只有源点在队列中，每次取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。

void spfa(int n)
{
    int i,temp;

    dis[n]=0;
    vis[n]=1;
    queue<int> Q;
    Q.push(n);

    while(!Q.empty())
    {
        temp=Q.front(); Q.pop();

        for(i=1; i<n;i++)
            if(dis[i]>dis[temp]+map[temp][i])
            {
                dis[i]=dis[temp]+map[temp][i];
                if(!vis[i])
                {
                    Q.push(i);
                    vis[i]=1;
                }
            }
        vis[temp]=0;
    }
}