Problem Description

雖然草兒是個路痴（就是在杭電待了一年多，居然還會在校園裡迷路的人，汗~),但是草兒仍然很喜歡旅行，因為在旅途中 會遇見很多人（白馬王子，^0^），很多事，還能豐富自己的閱歷，還可以看美麗的風景……草兒想去很多地方，她想要去東京鐵塔看夜景，去威尼斯看電影，去陽明山上看海芋，去紐約純粹看雪景，去巴黎喝咖啡寫信，去北京探望孟姜女……眼看寒假就快到了，這麼一大段時間，可不能浪費啊，一定要給自己好好的放個假，可是也不能荒廢了訓練啊，所以草兒決定在要在最短的時間去一個自己想去的地方！因為草兒的家在一個小鎮上，沒有火車經過，所以她只能去鄰近的城市坐火車（好可憐啊~）。

Input

輸入資料有多組，每組的第一行是三個整數T，S和D，表示有T條路，和草兒家相鄰的城市的有S個，草兒想去的地方有D個；
接著有T行，每行有三個整數a，b，time,表示a,b城市之間的車程是time小時；(1=<(a,b)<=1000;a,b 之間可能有多條路)
接著的第T+1行有S個數，表示和草兒家相連的城市；
接著的第T+2行有D個數，表示草兒想去地方。

Output

輸出草兒能去某個喜歡的城市的最短時間。

Sample Input

6 2 3
1 3 5
1 4 7
2 8 12
3 8 4
4 9 12
9 10 2
1 2
8 9 10

Sample Output

9

這裡和草兒家相鄰的城市其實可以看成是草兒假的城市

題意:

        給你一個無向圖,有s個起點和d個終點,現在要你求s個點中任意一點到d個終點中任意一點的最短距離.

分析:

        我們把題目給的原始點,編號1到N,然後我們新增0號點和N+1號點.其中0號點到s個起點的距離為0,d個終點與N+1號點的距離為0.等於是添加了一個超級源點和超級匯點.然後用Dijkstra演算法求從0到N+1號點的最短路徑即可.

        不過原題給的端點可能不連續(即只有3 7 8 9 等數,而不是從1到9),我們需要用map把序號對映到連續的n個數上.

        其實本題最簡單的方法是假設每個圖都有1000個點,我們新增0號點和1001號點即可.然後直接建立具有超級源點和匯點的圖,求最短路徑值即可.過程中那些原本不存在的點都是孤立的,不用管.(不過應該不會超時)
 

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<iostream>
using namespace std;
const int maxn = 1000+10;
#define INF 1e9
 
struct Edge
{
    int from,to,dist;
    Edge(int f,int t,int d):from(f),to(t),dist(d){}
};
 
struct HeapNode
{
    int d,u;
    HeapNode(int d,int u):d(d),u(u){}
    bool operator<(const HeapNode &rhs)const
    {
        return d>rhs.d;
    }
};
 
struct Dijkstra
{
    int n,m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool done[maxn];
    int d[maxn];
 
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }
 
    void AddEdge(int from,int to,int dist)
    {
        edges.push_back(Edge(from,to,dist));
        m = edges.size();
        G[from].push_back(m-1);
    }
 
    void dijkstra()
    {
        priority_queue<HeapNode> Q;
        for(int i=0;i<n;i++) d[i]=INF;
        d[0]=0;
        Q.push(HeapNode(d[0],0));
        memset(done,0,sizeof(done));
 
        while(!Q.empty())
        {
            HeapNode x=Q.top(); Q.pop();
            int u=x.u;
            if(done[u]) continue;
            done[u]=true;
 
            for(int i=0;i<G[u].size();i++)
            {
                Edge &e=edges[G[u][i]];
                if(d[e.to]>d[u]+e.dist)
                {
                    d[e.to]=d[u]+e.dist;
                    Q.push(HeapNode(d[e.to],e.to));
                }
            }
        }
    }
}DJ;
map<int,int> mp;//將原始城市編號對映到1-n中  //map陣列可以這樣理解<x,y>即mp[x]==y;
int n;
int ID(int x)   //新出現的編號 對映成 1-n的序號
{
    if(mp[x]==0) mp[x]=++n;
    return mp[x];
}
int u[maxn],v[maxn],d[maxn];
vector<int> start;//儲存起始點編號
vector<int> end;//儲存結束點編號
int main()
{
    int T,S,D;
    while(scanf("%d%d%d",&T,&S,&D)==3)
    {
        n=0;
        mp.clear();
        start.clear();
        end.clear();
        for(int i=0;i<T;i++)
        {
            scanf("%d%d%d",&u[i],&v[i],&d[i]);
            u[i]=ID(u[i]);  //原始編號對映成新的1-n之間的編號
            v[i]=ID(v[i]);
        }
 
        for(int i=0;i<S;i++)
        {
            int x; scanf("%d",&x);
            start.push_back(ID(x)); //儲存對映後的起點編號
        }
        for(int i=0;i<D;i++)
        {
            int x; scanf("%d",&x);
            end.push_back(ID(x));   //儲存對映後的終點編號
        }
 
        DJ.init(n+2);
        for(int i=0;i<T;i++)
        {
            DJ.AddEdge(u[i],v[i],d[i]);
            DJ.AddEdge(v[i],u[i],d[i]);
        }
        for(int i=0;i<start.size();i++)
        {
            DJ.AddEdge(0,start[i],0);   //超級源點到所有起點都有一條邊
        }
        for(int i=0;i<end.size();i++)
        {
            DJ.AddEdge(end[i],n+1,0);   //所有終點到超級匯點都有一條邊
        }
        DJ.dijkstra();
        printf("%d\n",DJ.d[n+1]);       //輸出0號點到n+1號點的最短距離
    }
    return 0;
}