畅通工程续——三种算法

Problem Description
某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

Input
本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0

#include<iostream>
#define inf 1e9
using namespace std;
int dist[205][205];
int main()
{
    int n,m,sta,fin;
    while(cin>>n>>m)
    {
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        {
        if(i!=j)
        dist[i][j]=inf;
        dist[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            cin>>x>>y>>z;
            if(dist[x][y]>z)
            dist[x][y]=dist[y][x]=z;
        }
        cin>>sta>>fin;
        for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        if(dist[i][j]>dist[i][k]+dist[k][j])
        dist[i][j]=dist[i][k]+dist[k][j];
        if(dist[sta][fin]<inf)
        cout<<dist[sta][fin]<<endl;
        else
        cout<<-1<<endl;
    }
    return 0;
}
第二种：spfa，用队列存储，类似bfs，只不过同一点可以出现多次，适用于2000以内的数据，
并且用于解决边权有负值的题目
#include<iostream>
#include<queue>
#include<string.h>
#define inf 1e9
using namespace std;
int val[205][205];
int dis[205];
int inq[205];
int n,m,sta,fin;
void spfa()
{
    queue<int>Q;
    dis[sta]=0;
    Q.push(sta);
    inq[sta]=1;
    while(!Q.empty())
    {
        int pos=Q.front();
        Q.pop();
        inq[pos]=0;
        for(int i=0;i<n;i++)
        {
            if(dis[i]>dis[pos]+val[pos][i])
            {
            dis[i]=dis[pos]+val[pos][i];
            if(inq[i])continue;
            Q.push(i);
            inq[i]=1;
            }
        }
    }
}
int main()
{
    while(cin>>n>>m)
    {
        memset(inq,0,sizeof(inq));
        for(int i=0;i<n;i++)
        {
            dis[i]=inf;
            for(int j=0;j<n;j++)
            val[i][j]=inf;
            val[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            cin>>x>>y>>z;
            if(val[x][y]>z)
            val[x][y]=val[y][x]=z;
        }
        cin>>sta>>fin;
        spfa();
        if(dis[fin]<inf)
        cout<<dis[fin]<<endl;
        else
        cout<<-1<<endl;
    }
    return 0;
}
第三种：迪杰斯特拉算法，这里的是用矩阵实现，只用于数值小于2000的题目，
推荐用链式前向星实现。
#include<iostream>
#include<string.h>
#define inf 1e9
using namespace std;
int n,m,sta,fin;
int dis[205];
int vis[205];
int val[205][205];
void dijkstra()
{
    int pos,minn;
    for(int i=0;i<n;i++)
    dis[i]=val[sta][i];
    vis[sta]=1;
    for(int i=0;i<n;i++)
    {
        pos=-1;
        minn=inf;
        for(int j=0;j<n;j++)
        if(!vis[j]&&dis[j]<minn)
        {
            minn=dis[j];
            pos=j;
        }
        if(pos==-1)
        continue;
        vis[pos]=1;
        for(int j=0;j<n;j++)
        if(!vis[j]&&dis[j]>dis[pos]+val[pos][j])
        dis[j]=dis[pos]+val[pos][j];
    }
}
int main()
{
    while(cin>>n>>m)
    {
        memset(vis,0,sizeof(vis));
        for(int i=0;i<n;i++)
        {
            dis[i]=inf;
            for(int j=0;j<n;j++)
            {
                val[i][j]=inf;
            }
            val[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            cin>>x>>y>>z;
            if(val[x][y]>z)
            val[x][y]=val[y][x]=z;
        }
        cin>>sta>>fin;
        dijkstra();
        if(dis[fin]<inf)
        cout<<dis[fin]<<endl;
        else
        cout<<-1<<endl;
    }
    return 0;
}