最短路相关模板、总结

1.

Dijkstra模板

 自己写一遍才知道可能犯的错误，囧。

HDU2544大水题一枚。 http://acm.hdu.edu.cn/showproblem.php?pid=2544

 

//1.注意INF的取值，不仅仅是最大边长度  2.注意W[i][j]的清空

void Dijk()

{

    memset(v,0,sizeof(v));

    for(int i=1;i<=n;i++)

        d[i]=(i==1)?0:INF;

    for(int i=1;i<=n;i++)

    {

        int x,m=INF;

        for(int j=1;j<=n;j++)

        {

            if(!v[j]&&d[j]<m)

              x=j,m=d[j];  //x:当前选出的最小点

        }

        v[x]=1;

        for(int j=1;j<=n;j++)

        {

            if(d[j]>(d[x]+w[x][j]))

                d[j]=d[x]+w[x][j];

        }

    }

}

 

边(x,y)上的松弛操作

if(d[j]>(d[x]+w[x][j]))
    {
           d[j]=d[x]+w[x][j];
           fa[j]=x;
     }

附POJ2387   http://poj.org/problem?id=2387

 ： Dijk不适合有重边的情况，（显然），然后需要自己判一下，囧。

或者只读入w[a][b]=c即可，但是要当a>b时，swap(a,b);

具体同临接表。自己发现，具体证明算导应该有吧。

临接表做法，适用与稀疏图，先给每条边编号，next[e]表示e的下一条边

总感觉自己写的模板没问题，可至今未过题，先放这。 

 

void adj()

{

    memset(visit,0,sizeof(visit));

    memset(next,-1,sizeof(next));

    for(int i=1;i<=n;i++)

       first[i]=-1,d[i]=(i==1)?0:INF;

    for(int i=1;i<=m;i++)

    {

       scanf("%d%d%d",&u[i],&v[i],&w[i]);//别忘交换。

       if(u[i]>v[i]) swap(u[i],v[i]);

       next[i]=first[u[i]];

       first[u[i]]=i;

    }

    for(int i=1;i<=n;i++) //这地方要循环n次

    {

        int x,temp=INF;

        for(int j=1;j<=n;j++)

            if(!visit[j]&&d[j]<temp) x=j,temp=d[j];

        visit[x]=1;

        for(int e=first[x];e!=-1;e=next[e])

        {

            if(d[v[e]]>(d[x]+w[e]))

                d[v[e]]=d[x]+w[e];

        }

    }

}

 

Dijkstra不能计算负权的原因：

 

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使得路径减小。

 

 

2、Floyd算法

 

//先初始化d[i][i]=0,其他为INF

    for(int k=0;k<n;k++)

        for(int i=0;i<n;i++)

          for(int j=0;j<n;j++)

            {

                if(d[i][j]>(d[i][k]+d[k][j]))

                    d[i][j]=d[i][k]+d[k][j];

            }

 

 

1.注意重边，选最小的边



2.注意如果自身到自身返回0



3.注意双向边   //这三条不管是用那个算法都注意一下。

   Floyd算法边权可正可负，不适合大量顶点。

   有向图的传递闭包：HDU1181

 

3、Bellman-ford算法  时间复杂度O（n*m）

 

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)

 

可以判断是否存在 负权环。

o(∩∩)o...哈哈，偶终于明白了。。

Bellman-ford也不能直接照着LRJ的代码敲，自己得加两种情况，就是考虑是有向图还是无向图。（每种最短路算法都要这样。）

妹的啊，Bellman-ford是判断负权环的，存在负权环可以来回走，负权边就不可以来回走了？