距离矢量路由算法(最短路Bellman-Ford实现)实现

using     namespace   std;

 
const     int   MAXN   =     100  ;
 
const     int   MAXV   =   MAXN   *   MAXN;
 
const     int   INF   =     2000000000  ;

 
struct   EDGE
  
{
     
int  u, v;
}
 ;

 
int   g[MAXN][MAXN];
EDGE e[MAXV];

 
int   BellmanFord(  int   beg,   int   end,   int   nNum,   int   eNum)
  
// nNum为顶点数, eNum为边数, 复杂度O(VE) 
      int  d[MAXN];
     
int  i, k;

     
for  (i = 0 ; i < nNum; i ++ )
        d[i]  
=  INF;
    d[beg]  
=   0 ;
    
     
bool  ex  =   true ;
     
for  (k = 1 ; k < nNum  &&  ex; k ++ )
      
{
        ex  
=   false ;
         
for  (i = 0 ; i < eNum; i ++ )
             
if  (d[e[i].u]  <  INF  &&  d[e[i].v]  >  d[e[i].u]  +  g[e[i].u][e[i].v])
              
{
                d[e[i].v]  
=  d[e[i].u]  +  g[e[i].u][e[i].v];
                ex  
=   true ;
            }
 
    }
 
 
     
return  d[end];
}
 
 
 
int   main()
  
{
     
int  i, j;
     
int  t  =   0 ;
     
int  eNum  =   0 ;
     
int  nNum  =   9 ;
     
for  (i = 0 ; i < 4 ; i ++ )
         
for  (j = 0 ; j < 4 ; j ++ )
          
{
             
if  (i  ==  j) 
              
{
                g[i][j]  
=  INF;
            }
 
             
else 
               
{
                g[i][j]  
=   ++ t;
                e[eNum].u  
=  i;
                e[eNum].v  
=  j;
                eNum 
++ ;
            }
 
        }
     
    cout  
<<  BellmanFord( 2 ,  3 , nNum, eNum)  <<  endl;
     
return   0 ;
}
 

你可能感兴趣的:(for)