最短路径 和 最小代价生成树

单源最短路径

Dijkstra 算法复杂度 O(V^2 + E)

有向加权图， 所有边非负

 

Bellman-Ford 算法复杂度O(VE)

有向加权图, 权可为负, 可存在负回路

代码

         for  ( int  i  =   0 ; i  <  N  -   1 ;  ++ i)
             for  ( int  j  =   0 ; j  <  SIZE;  ++ j)
                d[paths[j][ 1 ]]  =  min(d[paths[j][ 0 ]]  +  paths[j][ 2 ],d[paths[j][ 1 ]]);

         bool  avbl  =   false ;
         for  ( int  j  =   0 ; j  <  SIZE;  ++ j)
             if  (d[paths[j][ 1 ]]  >  d[paths[j][ 0 ]]  +  paths[j][ 2 ])
            {
                avbl  =   true ;
                 break ;
            };

 

 

每对节点的最短路径

Floyd-Warshall算法复杂度 O(V^3)

有向加权图, 权可为负, 但不存在负回路

代码

         for  ( int  k  =   0 ; k  <  currencies;  ++ k)
             for  ( int  i  =   0 ; i  <  currencies;  ++ i)
                 for  ( int  j  =   0 ; j  <  currencies;  ++ j)
                    d[i][j]  =  max(d[i][k]  *  d[k][j],d[i][j]);

 

最小代价生成树

Prim 算法复杂度 O(V^2 + E) 实现与Dijkstra 类似

代码

         // init for prim
        l[ 0 ]  =   0 ;
        memset(used,  0 ,  sizeof (used));
        used[ 0 ]  =   true ;
         for  ( int  i  =   0 ; i  <  lines;  ++ i) l[i]  =  d[ 0 ][i];

         for  ( int  i  =   1 ; i  <  lines;  ++ i)
        {
             //  select available V with min len
             int  pos  =   0 ;
             int  len  =   8 ;
             for  ( int  j  =   0 ; j  <  lines;  ++ j)
                 if  (used[j]  ==   false   &&   len  >  l[j])
                {
                    len  =  l[j];
                    pos  =  j;
                };

             // update l[]
            used[pos]  =   true ;
             for  ( int  j  =   0 ; j  <  lines;  ++ j)
                 if  (used[j]  ==   false   &&  l[j]  >  d[pos][j]) l[j]  =  d[pos][j];

        }