最短路HDU2544

SPFA：

/****************************************
*****************************************
*        Author:Tree                    *
*From :http://blog.csdn.net/lttree      *
* Title : 最短路                       *
*Source: hdu 2544                       *
* Hint : 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\n",d[n]);
    }
    return 0;
}

Dijkstra：

/****************************************
*****************************************
*        Author:Tree                    *
*From :http://blog.csdn.net/lttree      *
* Title : 最短路                       *
*Source: hdu 2544                       *
* Hint : 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\n",d[n]);
    }
    return 0;
}

Floyd：

/****************************************
*****************************************
*        Author:Tree                    *
*From :http://blog.csdn.net/lttree      *
* Title : 最短路                       *
*Source: hdu 2544                       *
* Hint : 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\n",d[1][n]);
    }
    return 0;
}