fzu-2261（spfa打印最短路径，求最短路）

TonyY是一个喜欢到处浪的男人，他的梦想是带着兰兰姐姐浪遍天朝的各个角落，不过在此之前，他需要做好规划。

现在他的手上有一份天朝地图，上面有n个城市，m条交通路径，每条交通路径都是单行道。他已经预先规划好了一些点作为旅游的起点和终点，他想选择其中一个起点和一个终点，并找出从起点到终点的一条路线亲身体验浪的过程。但是他时间有限，所以想选择耗时最小的，你能告诉他最小的耗时是多少吗？

Input
包含多组测试数据。

输入第一行包括两个整数n和m，表示有n个地点，m条可行路径。点的编号为1 - n。

接下来m行每行包括三个整数i, j, cost，表示从地点i到地点j需要耗时cost。

接下来一行第一个数为S，表示可能的起点数，之后S个数，表示可能的起点。

接下来一行第一个数为E，表示可能的终点数，之后E个数，表示可能的终点。

0<S, E≤n≤100000，0<m≤100000，0<cost≤100。

Output
输出他需要的最短耗时。

Sample Input
4 4
1 3 1
1 4 2
2 3 3
2 4 4
2 1 2
2 3 4
Sample Output

1

之前碰到过一次spfa，就跑过去学习了一下。 很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。有人称spfa算法是最短路的万能算法。

spfa与bfs很像，但是bfs出队列后，就永远不可能再进来了，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进(重新入队)，于是再次用来改进其它的点，这样反复迭代下去。

具体代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N=100005;
const int inf=0x3f3f3f;
struct Node
{
    int v,w,next;
}a[N];
int len=0,f[N],dist[N],vis[N];
int s[N],e[N];
int c[N];//记录每一个点访问的次数
int path[N];//记录路径
void add_edge(int u,int v,int w)//构建以u节点为根节点的邻接表，
{
    a[len].w=w;
    a[len].v=v;
    a[len].next=f[u];//next记录上一个邻接节点。
    f[u]=len++;
}
void spfa(int start)
{
    memset(dist,inf,sizeof(dist));//初始化距离为无穷大。
    memset(vis,0,sizeof(vis));//
    memset(c,0,sizeof(c));//
    memset(path,0,sizeof(path));
    queue<int> q;
    q.push(start);
    dist[start]=0;//到自身的距离为0
    vis[start]=1;
    c[start]=1;
    bool ok=true;//判断是否有负权环

    while(!q.empty())
    {
        start=q.front();
        q.pop();
        vis[start]=0;//队首元素出队，并取消标记
        for(int i=f[start];i!=-1;i=a[i].next)
        {
            int v=a[i].v,w=a[i].w;
            path[v]=start;
            if(dist[start]+w<dist[v])
            {
                dist[v]=dist[start]+w;//松弛操作
                if(!vis[v])//顶点不在队列
                {
                    q.push(v);//入队
                    vis[v]=1;//标记
//                    c[v]++;
//                    if(c[v]>NN)//超过入队次数上限，说明有负权边
//                    {
//                        ok=false;
//                        break;
//                    }
                }
            }
        }
    }
}
void printpath(int k)
{
    if(path[k])
        printpath(path[k]);
    cout<<k<<" ";
}
int main()
{
    int n,m,u,v,w;
    int num_s,num_e;
    long long ans;
    while(~scanf("%d%d",&n,&m))
    {
        len=0;
        ans=inf;
        memset(f,-1,sizeof(f));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);//构建邻接表
        }
        scanf("%d",&num_s);
        for(int i=0;i<num_s;i++)
            scanf("%d",&s[i]);
        scanf("%d",&num_e);
        for(int i=0;i<num_e;i++)
        {
            scanf("%d",&e[i]);
        }
        for(int i=0;i<num_s;i++)
        {
            spfa(s[i]);//s[i]作为起点
            int x;
            for(int j=0;j<num_e;j++)
            {
                if(dist[e[j]]<ans)
                {
                    ans=dist[e[j]];
                    x=e[j];
                }

            }
//            printf("%d到%d的最短路径为\n",s[i],x);
//            printpath(x);
//            printf("\n");
        }
        cout<<ans<<endl;
    }
    return 0;
}