oj 2143 图结构练习——最短路径的几种算法

图结构练习——最短路径

Description
给定一个带权无向图，求节点1到节点n的最短路径。

Input
输入包含多组数据，格式如下。
第一行包括两个整数n m，代表节点个数和边的个数。(n<=100)
剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。

Output
每组输出占一行，仅输出从1到n的最短路径权值。（保证最短路径存在）

Sample
Input
3 2
1 2 1
1 3 1
1 0
Output
1
0

Floyd、Dijkstra、Bellman、SPFA求最短路

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

using namespace std;

struct node
{
    int u,v,w;
}s[5000010];
struct nd
{
    int ver,weight;
    int next;
}edge[20010];
int head[105];
int Map[105][105];
int dis[3000010],vis[105];
int n,m,cnt;

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;
}