最短路 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=1;i<=n;++i )
  {
    d[i]=MAX;
    used[i]=false;
  }

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

  while(!q.empty())
  {
    now = q.front();
    q.pop();
    used[now] = false;
    for(i = 1; i <= n; i++)
    {
      if(d[i] > d[now] + cost[now][i])
      {
        d[i] = d[now] + cost[now][i];
        if(used[i] == 0)
        {
          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=1;i<=n;++i )
      for( j=1;j<=i;++j )
        if( i==j )  cost[i][j]=0;
        else    cost[i][j]=cost[j][i]=MAX;

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

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

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=1;i<=n;++i )
  {
    used[i]=false;
    d[i]=cost[1][i];
  }
  d[s]=0;

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

    for( u=1;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=1;i<=n;++i )
      for( j=1;j<=i;++j )
        if( i==j )  cost[i][j]=0;
        else    cost[i][j]=cost[j][i]=MAX;

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

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

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=1;k<=n;++k )
    for( i=1;i<=n;++i )
      for( j=1;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=1;i<=n;++i )
      for( j=1;j<=i;++j )
      {
        if( i==j ) d[i][j]=0;
        else    d[i][j]=d[j][i]=MAX;
      }

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

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