最短路的三种方法——Dijkstra、Floyd、Bellman

以 OJ 2143 题目为例

图结构练习——最短路径

#include <iostream>
#include <bits/stdc++.h>
#define inf 0x3f3f3f3f

using namespace std;

struct node       //用于Bellman的结构体
{
    int u,v,w;
}s[5000010];
int head[105];

int Map[105][105];
int dis[3000010],vis[105];
int n,m,cnt;

struct nd        //用于SPFA的链式前向星
{
    int ver,weight;
    int next;
}edge[20010];

void Floyd(int n)
{
    int i,j,k;
    for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
            {
                if(Map[i][j]>(Map[i][k]+Map[k][j]))
                    Map[i][j]=Map[i][k]+Map[k][j];
            }
}

void Floyd_main()
{
    int i;
    int a,b,c;
    while(cin>>n>>m)
    {
        memset(Map,inf,sizeof(Map));
        for(i=1;i<=n;i++)
            Map[i][i]=0;
        for(i=0;i<m;i++)
        {
            cin>>a>>b>>c;
            if(Map[a][b]>c)         //防止出现环？
                Map[a][b]=Map[b][a]=c;
        }
        Floyd(n);
        cout<<Map[1][n]<<endl;
    }
}

void Dijkstra(int n)
{
    int i,j,v,u,min_;
    for(i=1;i<n;i++)    //进行n-1次最小值查找
    {
        min_=inf;
        for(j=1;j<=n;j++)
        {
            if(vis[j]==0&&dis[j]<min_)  //判断最小值是否确定
            {
                min_=dis[j];
                u=j;
            }
        }
        vis[u]=1;
        for(v=1;v<=n;v++)
        {
            if(dis[v]>dis[u]+Map[u][v])
                dis[v]=dis[u]+Map[u][v];
        }
    }
    cout<<dis[n]<<endl;
}

void Dijkstra_main()
{
    int a,b,c,i;
    while(cin>>n>>m)
    {
        memset(Map,inf,sizeof(Map));
        memset(vis,0,sizeof(vis));
        vis[1]=1;
        for(i=1;i<=n;i++)
            Map[i][i]=0;
        for(i=0;i<m;i++)
        {
            cin>>a>>b>>c;
            if(Map[a][b]>c)
                Map[a][b]=Map[b][a]=c;
        }
        for(i=1;i<=n;i++)
            dis[i]=Map[1][i];
        Dijkstra(n);
    }
}

void Bellman_add(int u,int v,int w)
{
    s[cnt].u=u;
    s[cnt].v=v;
    s[cnt].w=w;
    cnt++;
}

void Bellman(int x,int y)
{
    int i,j,check;
    memset(dis,inf,sizeof(dis));
    dis[x]=0;
    for(i=1;i<n;i++)
    {
        check=0;
        for(j=1;j<cnt;j++)
        {
            if(dis[s[j].v]>dis[s[j].u]+s[j].w)
            {
                dis[s[j].v]=dis[s[j].u]+s[j].w;
                check=1;
            }
        }
        if(check==0)
            break;
    }
    cout<<dis[y]<<endl;
}

void Bellman_main()
{
    int a,b,c;
    while(cin>>n>>m)
    {
        cnt=1;
        for(int i=1;i<=m;i++)
        {
            cin>>a>>b>>c;
            Bellman_add(a,b,c);
            Bellman_add(b,a,c);
        }
        Bellman(1,n);
    }
}

void add_edge(int u,int v,int w)
{
    edge[cnt].ver=v;
    edge[cnt].weight=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

void SPFA()
{
    queue<int>Q;
    int x;
    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[1]=0; Q.push(1); vis[1]=1;
    while(!Q.empty())
    {
        x=Q.front();
        Q.pop();
        vis[x]=0;
        for(int i=head[x];i!=-1;i=edge[i].next)
        {
            if(dis[edge[i].ver]>dis[x]+edge[i].weight)
            {
                dis[edge[i].ver]=dis[x]+edge[i].weight;
                if(!vis[edge[i].ver])
                {
                    Q.push(edge[i].ver);
                    vis[edge[i].ver]=1;
                }
            }
        }
    }
}

void SPFA_main()
{
    int i,a,b,c;
    while(cin>>n>>m)
    {
        memset(head,-1,sizeof(head));
        cnt=0;
        for(i=0;i<m;i++)
        {
            cin>>a>>b>>c;
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        SPFA();
        cout<<dis[n]<<endl;
    }
}

int main()
{
    //Floyd_main();       //多源最短路
    //Dijkstra_main();    //单源最短路
    //Bellman_main();     //dis数组比较大
    SPFA_main();
    return 0;
}