【最短路径spfa算法】HDU 1874---畅通工程续

畅通工程续

Problem Description

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

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

Input

本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

Sample Input

  
  

   
   3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2
  
  

Sample Output

  
  

   
   2
-1
  
  

 第一种为SPFA算法

/*
编辑本段SPFA算法
　　求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。 　　SPFA算法是西南交通大学段凡丁于1994年发表的. 　　从名字我们就可以看出，这种算法在效率上一定有过人之处。 

　　很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 　　简洁起见，我们约定有向加权图G不存在负权回

路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。 　　我们用数组d记录每个结点的最短路径估计值，而且用邻接表来

存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v

点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 　　定理: 只要最短路径存在，上述SPFA算法必定能求出最

小值。 　　证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，

所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕） 　　期望的时间

复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。 　　实现方法：建立一个队列，初始时队列里只有起始点，在建立一个表格记录起始点到所有点的最短路径（该表格的初

始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队

列为空 　　判断有无负环：如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）
*/


// 该注意的是有些点可能重复入队，所以出队的点也要重新置未标记

#include<iostream>
#include<algorithm>
using namespace std;
int arc[200][200];
int cost[200];
int INF=10000; 
int n,s,t;

void spfa()
{
    int x,i;
    int q[200];
    int visited[200];
    int front=0,rear=0;
    memset(q,0,sizeof(q));
    memset(visited,0,sizeof(visited));
    cost[s]=0;
    q[++rear]=s;
    visited[s]=1;
    while(front!=rear)
    {
        front=(front+1)%(n+1);
        x=q[front];
        visited[x]=0;  // 置出队的点未标记
        for(i=0;i<n;i++)
            if(cost[x]+arc[x][i]<cost[i])
            {
                cost[i]=arc[x][i]+cost[x]; //更新路径
                if(!visited[i])  // 未被访问
                {
                    rear=(rear+1)%(n+1);
                    q[rear]=i;
                    visited[i]=1;
                }
            }
    }
}

int main()
{
    int m;
    while(cin>>n>>m)
    {
        int i,j,k,d;
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                arc[i][j]=INF;

        for(k=0;k<m;k++)
        {
            scanf("%d%d%d",&i,&j,&d);
            if(arc[i][j]>d)
                arc[i][j]=arc[j][i]=d;
        }

        cin>>s>>t;
        for(i=0;i<n;i++)
            cost[i]=INF;

        spfa();
        if(cost[t]<INF)
            cout<<cost[t]<<endl;
        else
            cout<<-1<<endl;
    }
    return 0;
}

第二种为dijkstra算法

#include<iostream>
#include<string>
using namespace std;
int arc[201][201];
int cost[201];
int minedge(int *p,int c)
{
    int i;
    int min=10000;
    int t=-1;
    for(i=0;i<c;i++)
    {
        if(cost[i]!=-1&&p[i]<min)
        {
            min=p[i];
            t=i;
        }
    }
//    cout<<"abc"<<t<<"abc"<<endl;
    return t;
}
int main()
{
    int i,j,k,d;
    int n,m;
    while(cin>>n>>m)
    {
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                arc[i][j]=10000;
        for(i=0;i<n;i++)
            arc[i][i]=0;
    //    memset(arc,0,n*n*sizeof(int));
        for(k=0;k<m;k++)
        {
            scanf("%d%d%d",&i,&j,&d);
            if(arc[i][j]>d)
            {
            arc[i][j]=d;
            arc[j][i]=d;
            }
        }
        int s,t;
        cin>>s>>t;
        if(s==t)
        {
            cout<<0<<endl;
            continue;
        }
        for(i=0;i<n;i++)
            cost[i]=arc[s][i];
        cost[s]=-1;
        for(i=0,k=s;i<n-1;i++)
        {
            k=minedge(cost,n);
            if(k==-1)break;
                if(k==t)
            {
            cout<<cost[t]<<endl;
            break;
            }
            
            for(j=0;j<n;j++)
                if(cost[j]!=-1&&arc[k][j]+cost[k]<cost[j])
                    cost[j]=arc[k][j]+cost[k];
                cost[k]=-1;
        }
        if(k!=t)
            cout<<"-1"<<endl;
        
    }
    return 0;
}