HDU2066最短路

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {

        public static void main(String[] args) throws IOException{
                StreamTokenizer cin = new StreamTokenizer(new BufferedInputStream(System.in)); 
                InputReader in = new InputReader(System.in)  ;
                PrintWriter out = new PrintWriter(System.out) ;
                while(cin.nextToken() != cin.TT_EOF){
                      new Task().solve(cin, out)  ;      
                }

                out.flush() ;
        }

}

class  Task{

       static class E{
              int v ;
              int w ;
              public  E(int v , int w){
                      this.v = v ;
                      this.w = w ;
              }
       }

       int T , S , D ; 
       ArrayList<E> adj[] ;
       boolean[] isEnd  ;
       int  dist[] ;

       public void solve(StreamTokenizer cin , PrintWriter out) throws IOException{
              T = (int)cin.nval ;   
              cin.nextToken() ;  S = (int)cin.nval ;   
              cin.nextToken() ;  D = (int)cin.nval ;  
              adj = new ArrayList[1001] ;
              for(int i = 1 ; i<= 1000 ; i++)  adj[i] = new ArrayList<Task.E>() ;

              for(int i = 0 ; i < T ; i++){
                   cin.nextToken() ;   int u = (int)cin.nval ;   
                   cin.nextToken() ;   int v = (int)cin.nval ;   
                   cin.nextToken() ;   int w = (int)cin.nval ; 
                   adj[u].add(new E(v, w)) ;
                   adj[v].add(new E(u, w)) ;
              }

              PriorityQueue<E> que = new PriorityQueue<E>(11 , new Comparator<E>(){
                        public int compare(E a , E b){ 
                               return a.w - b.w  ;
                        }
                      }
              ) ;

              dist = new int[1001] ;
              Arrays.fill(dist, Integer.MAX_VALUE) ;
              for(int i = 0 ; i < S ; i++){
                     cin.nextToken() ; int u = (int)cin.nval ;   
                     que.add(new E(u, 0)) ;
                     dist[u] = 0 ;
              }

              isEnd = new boolean[1001] ;
              Arrays.fill(isEnd, false) ;
              for(int i = 0 ; i < D ; i++){
                     cin.nextToken() ; int u = (int)cin.nval ;   
                     isEnd[u] = true ;
              }

              int ans = Integer.MAX_VALUE ;
              while(! que.isEmpty()){
                    E e = que.poll() ;  
                    if(isEnd[e.v]) ans = Math.min(ans, e.w) ;
                    for(E i : adj[e.v]){
                         if(e.w + i.w < dist[i.v]){
                              dist[i.v] = e.w + i.w  ;
                              que.add(new E(i.v, dist[i.v])) ;
                         }
                    }
              }

              out.println(ans);
       }
}




class InputReader{
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream){
           reader = new BufferedReader(new InputStreamReader(stream), 32768);
           tokenizer = null;
    }

    public String next(){
        while(tokenizer == null || !tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            }catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}