HDU 1874 畅通工程续 最短路算法检验题

转载请注明该文链接

题意：给一些结点，一些无向边，给起点a终点b，求最短距离。

思路：直接建图跑一遍SPFA（或其他的所有的最短路算法）。可以作为所有最短路算法代码的检验题。

代码：

dijkstra

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=210;
const int inf=0x3f3f3f3f;

int m,n,E[maxn][maxn];
int d[maxn],p[maxn];

void Dijkstra(int s)
{
    bool vis[maxn];
    fill(vis,vis+maxn,false);
    fill(d,d+maxn,inf);
    fill(p,p+maxn,inf);
    d[s]=0;
    while(1)
    {
        int u=-1;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i] && (u==-1 || d[i]<d[u])) u=i;
        }
        if(u==-1 || d[u]==inf) break;
        vis[u]=true;
        for(int v=1;v<=n;v++)
        {
            if(!vis[v] && d[u]+E[u][v]<d[v])
            {
                d[v]=d[u]+E[u][v];
                p[v]=u;
            }
        }
    }
}

int main()
{
    int a,b,dis;
    while(~scanf("%d%d",&n,&m))
    {
        fill(E[0],E[0]+maxn*maxn,inf);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&dis);
            a++,b++;
            if(E[a][b]>dis) E[a][b]=E[b][a]=dis;
        }
        int s,t;
        scanf("%d%d",&s,&t);
        s++,t++;
        Dijkstra(s);
        if(d[t]==inf) printf("-1\n");
        else printf("%d\n",d[t]);
    }
    return 0;
}

Bellman-Ford

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

using namespace std;

const int MAXV=210;
const int MAXE=1100;
const int inf=0x3f3f3f3f;

int n,m,E[MAXV][MAXV];
int d[MAXV];

bool Bellman_Ford(int s)
{
    memset(d,inf,sizeof(d));
    d[s]=0;
    for(int i=0;i<n-1;i++)
    {
        for(int u=0;u<n;u++)
        {
            for(int v=0;v<n;v++)
            {
                if(E[u][v]!=inf)
                {
                    if(d[v]>E[u][v]+d[u])
                    {
                        d[v]=E[u][v]+d[u];
                    }
                }
            }
        }
    }
    for(int u=0;u<n;u++)
    {
        for(int v=0;v<n;v++)
        {
            if(d[v]>E[u][v]+d[u]) return false;
        }
    }
    return true;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(E,inf,sizeof(E));
        int a,b,c;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(E[a][b]>c) E[a][b]=E[b][a]=c;
        }
        int s,t;
        scanf("%d%d",&s,&t);
        bool flag=Bellman_Ford(s);
        if(flag==false || d[t]==inf) printf("-1\n");
        else printf("%d\n",d[t]);
    }
    return 0;
}

Floyd

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>

using namespace std;

const int N=210;
const int inf=0x3f3f3f3f;

int n,m;
int d[N][N];

void Floyd()
{
    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(d,inf,sizeof(d));
        for(int i=0;i<n;i++) d[i][i]=0;
        int a,b,c;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(d[a][b]>c) d[a][b]=d[b][a]=c;
        }
        Floyd();
        scanf("%d%d",&a,&b);
        if(d[a][b]==inf) printf("-1\n");
        else printf("%d\n",d[a][b]);
    }
    return 0;
}