最短路 spfa， dijkstra， Floyd

spfa

 #include <stdio.h>
 #include <queue>
 using namespace std;

 #define RANGE 101
 #define MAX 0x3f3f3f3f
 int cost[RANGE][RANGE];
 int d[RANGE];
 bool used[RANGE];
 int n,m;

 void spfa( int s )
 {
   int i,now;
   // 初始化
   for( i=;i<=n;++i )
   {
     d[i]=MAX;
     used[i]=false;
   }

   d[s]=;
   queue <int> q;
   q.push(s);
   used[s] = true;

   while(!q.empty())
   {
     now = q.front();
     q.pop();
     used[now] = false;
     for(i = ; i <= n; i++)
     {
       if(d[i] > d[now] + cost[now][i])
       {
         d[i] = d[now] + cost[now][i];
         if(used[i] == )
         {
           q.push(i);
           used[i] = true;
         }
       }
     }
   }
 }

 int main()
 {
   int i,j,A,B,C;
   while( scanf("%d%d",&n,&m) )
   {
     if( !n && !m )  break;
     // 初始化
     for( i=;i<=n;++i )
       for( j=;j<=i;++j )
         if( i==j )  cost[i][j]=;
         else    cost[i][j]=cost[j][i]=MAX;

     for( i=;i<m;++i )
     {
       scanf("%d%d%d",&A,&B,&C);
       cost[A][B]=cost[B][A]=C;
     }

     spfa();
     printf("%d\n",d[n]);
   }
   return ;
 }

dijkstra

 #include <stdio.h>
 #define MAX 0x3f3f3f3f
 #define RANGE 101

 int cost[RANGE][RANGE];
 int d[RANGE];
 bool used[RANGE];

 int n,m;
 int Min( int a,int b )
 {
   return a<b?a:b;
 }

 void Dijkstra( int s )
 {
   int i,v,u;
   for( i=;i<=n;++i )
   {
     used[i]=false;
     d[i]=cost[][i];
   }
   d[s]=;

   while( true )
   {
     v=-;
     for( u=;u<=n;++u )
       if( !used[u] && ( v==- || d[u]<d[v]) )
         v=u;
     if( v==- ) break;
     used[v]=true;

     for( u=;u<=n;++u )
       d[u]=Min( d[u],d[v]+cost[v][u] );
   }
 }

 int main()
 {
   int A,B,C,i,j;

   while( scanf("%d%d",&n,&m) )
   {
     if( !n && !m )  break;

     // 初始化
     for( i=;i<=n;++i )
       for( j=;j<=i;++j )
         if( i==j )  cost[i][j]=;
         else    cost[i][j]=cost[j][i]=MAX;

     for( i=;i<m;++i )
     {
       scanf("%d%d%d",&A,&B,&C);
       cost[A][B]=cost[B][A]=C;
     }

     Dijkstra();
     printf("%d\n",d[n]);
   }
   return ;
 }

floyd

 #include <stdio.h>
 #define MAX 0x3f3f3f3f
 #define RANGE 105

 int d[RANGE][RANGE];
 int n;

 int Min( int a,int b )
 {
   return a<b?a:b;
 }
 void warshall_floyd( void )
 {
   int i,j,k;
   for( k=;k<=n;++k )
     for( i=;i<=n;++i )
       for( j=;j<=n;++j )
         d[i][j]=Min( d[i][j],d[i][k]+d[k][j] );
 }

 int main()
 {
   int m,A,B,C,i,j;

   while( scanf("%d%d",&n,&m) )
   {
     if( !n && !m )  break;

     // 初始化
     for( i=;i<=n;++i )
       for( j=;j<=i;++j )
       {
         if( i==j ) d[i][j]=;
         else    d[i][j]=d[j][i]=MAX;
       }

     // 输入
     for( i=;i<m;++i )
     {
       scanf("%d%d%d",&A,&B,&C);
       d[A][B]=d[B][A]=C;
     }

     // floyd算法求最短路
     warshall_floyd();
     printf("%d\n",d[][n]);
   }
   return ;
 }