最短路（建图）—— Meeting （HDU 5521）

• 题目链接：
  http://acm.hdu.edu.cn/contests/contest_showproblem.php?pid=1013&cid=645

• 分析：
  给出 N 个点，给出M个集合，每个集合里的点可以互相抵达且耗时为$t_i$，现在分别从1和n点出发，求在哪个点相遇耗时最小，若有多个解，则按递增序列输出

• 题解：
  若是每个点直接建边，来两发SPFA，肯定T到生活不能自理，因为这个图的边不是一般的多。算法上肯定是选择最短路，所以我们可以优化一下我们的建图。题中很画蛇添足地加了一个集合的条件，我们可以从这儿入手：集合之间的点才可以互相抵达，即点之间若想抵达肯定属于同一个集合，所以我们可以把点之间的边换成点到集合的建边。这样从一个点出发，先访问这个点所属于的所有集合，再访问这些集合里的点，可以大大缩减建边数量，eg: 一个集合里有10个点，若点点建边，每个点需要连另外9个点，即一共90条边；而点与集合建边，则每个点与集合建双向边即可，一共20条边。

• AC代码：
  

/*************************************************************************
    > File Name: test.cpp
    > Author: Akira 
    > Mail: qaq.febr2.qaq@gmail.com 
 ************************************************************************/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <set>
#include <list>
#include <ctime>
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))
using namespace std;

#define MaxN 212345
#define MaxM MaxN*21
#define INF 0x3f3f3f3f
#define bug cout<<88888888<<endl;

int T;
int n,m;

struct Edge
{
    int u,v;
    int cost;
    int next;
}edge[MaxM];


int head[MaxN];
int cont;

void add(int u, int v, int cost)
{
    edge[cont].v = v;
    edge[cont].u = u;
    edge[cont].cost = cost;
    edge[cont].next = head[u];
    head[u] = cont++;
}

void Add(int u, int v, int cost)   //添加u-v，权重为cost的边，这个建的是双向，可以改
{
    add(u, v, 0);  
    add(v, u, cost);   
}

void init()                 //!!!!!!!!每次建图前记得init!!!
{
    cont = 0;
    MST(head,-1);
}

bool vis [MaxN];
int dis [MaxN];

int SPFA(int s, int t)
{
    int k, p, V;
    queue<int> q;
    CLR(vis);
    for(int i=1;i<=n+m;i++) dis[i] = INF;
    q.push(s);
    vis[s] = 1;
    dis[s] = 0;
    while(!q.empty())
    {
        k = q.front();
        q.pop();
        vis[k] = 0;
        for(p = head[k]; p!=-1; p = edge[p].next)
        {
            V = edge[p].v;
            if(edge[p].cost + dis[k] < dis[V])
            {
                dis[V] = edge[p].cost + dis[k];
                if(!vis[V])
                {
                    q.push(V);
                    vis[V] = 1;
                }
            }
        }
    }
    if(dis[t] == INF) return -1;   //表示有负权
    return dis[t];
}

int E[112345];
int main()
{
    cin >> T;
    for(int cas=1; cas<=T;cas++)
    {
        init();
        scanf("%d%d", &n, &m);
        int t;
        int S;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d", &t, &S);
            while(S--)
            {
                int x;
                scanf("%d", &x);
                Add(x, i+n, t);
            }
        }
        if(SPFA(1,n) == -1)
        {
            cout << "Case #" << cas << ": Evil John\n";
        }
        else
        {
            for(int i=1;i<=n;i++)
            {
               // cout << i << ":" << dis[i] << endl;
                E[i] = dis[i];
            }
            SPFA(n,1);
            for(int i=1;i<=n;i++)
            {
                dis[i] = E[i] > dis[i] ? E[i] : dis[i];
            }
            int Min = INF;
            int ans[112345];
            for(int i=1;i<=n;i++)
            {
                Min = Min < dis[i] ? Min : dis[i];
            }
            cout << "Case #" << cas << ": "<< Min <<endl;
            int cnt = 0;
            for(int i=1;i<=n;i++)
            {
                if(dis[i] == Min)
                    ans[cnt++] = i;
            }
            for(int i=0;i<cnt-1;i++)
                cout << ans[i] << " ";
            cout << ans[cnt-1] << endl;
        }
    }
    system("pause");
}