浪里个浪 FZU - 2261（最短路好题）

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

题意：n个城市，m条单向道路，s个可能的起点，e个可能的终点，问从起点到终点的最短时间是多少。

思路：比赛时想的是既然s个起点，那每个起点都跑一遍spfa然后遍历找到终点最短的路程即可。但是这样的复杂度太高了，应该是会超时的，没想到后台数据不大，这样写竟然过了，哈哈哈

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<stack>
#include<math.h>
using namespace std;
#define inf 0x3f3f3f3f
const int N=1e5+10;
int m,n,a[N],b[N],dis[N],tot,head[N],sa[N],sb[N],s1,s2;
bool vis[N];
struct node
{
    int v,dis,net;
}e[N];
void add(int a,int b,int c)
{
    e[tot].v=b;
    e[tot].dis=c;
    e[tot].net=head[a];
    head[a]=tot++;
}
void spfa(int st)
{
    memset(dis,0x3f,sizeof(dis));
    memset(vis,false,sizeof(vis));
    queue<int>q;
    dis[st]=0;
    vis[st]=true;
    q.push(st);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int j=head[u];j!=-1;j=e[j].net)
        {
            int v=e[j].v,dist=e[j].dis;
            if(dis[v]>dis[u]+dist)
            {
                dis[v]=dis[u]+dist;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
}
int main()
{
    int u,v,wt;
    while(~scanf("%d%d",&n,&m))
    {
        int ans=inf;
        tot=0;
        memset(head,-1,sizeof(head));
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&wt);
            add(u,v,wt);
        }
        scanf("%d",&s1);
        for(int i=0;i<s1;i++)
            scanf("%d",&sa[i]);
        scanf("%d",&s2);
        for(int i=0;i<s2;i++)
            scanf("%d",&sb[i]);
        for(int i=0;i<s1;i++)
        {
            spfa(sa[i]);
            for(int j=0;j<s2;j++)
                ans=min(ans,dis[sb[j]]);
        }
        printf("%d\n",ans);
    }
}

那这题的正解是什么呢？那就是添加一个超级起点和一个超级终点，让所有可能的起点到超级起点的距离都为0，所有可能的终点到超级终点的距离都为0，然后只要跑一遍spfa找到超级起点到超级终点的最短时间就是我们所要的答案了

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<stack>
#include<math.h>
using namespace std;
#define inf 0x3f3f3f3f
const int N=1e5+10;
int m,n,a[N],b[N],dis[N],tot,head[N],sa[N],sb[N],s1,s2;
bool vis[N];
struct node
{
    int v,dis,net;
}e[N*10];
void add(int a,int b,int c)
{
    e[tot].v=b;
    e[tot].dis=c;
    e[tot].net=head[a];
    head[a]=tot++;
}
void spfa()
{
    memset(dis,0x3f,sizeof(dis));
    memset(vis,false,sizeof(vis));
    queue<int>q;
    dis[0]=0;
    vis[0]=true;
    q.push(0);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int j=head[u];j!=-1;j=e[j].net)
        {
            int v=e[j].v,dist=e[j].dis;
            if(dis[v]>dis[u]+dist)
            {
                dis[v]=dis[u]+dist;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
    printf("%d\n",dis[n+1]);
}
int main()
{
    int u,v,wt;
    while(~scanf("%d%d",&n,&m))
    {
        tot=0;
        memset(head,-1,sizeof(head));
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&wt);
            add(u,v,wt);
        }
        scanf("%d",&s1);
        for(int i=0;i<s1;i++)
        {
            scanf("%d",&sa[i]);
            add(0,sa[i],0);//超级起点到所有可能起点的时间为0
        }
        scanf("%d",&s2);
        for(int i=0;i<s2;i++)
        {
            scanf("%d",&sb[i]);
            add(sb[i],n+1,0);//所有可能终点到超级终点的时间为0
        }
        spfa();
    }
}