Problem:
JOI 国のお祭り事情(Festivals in JOI Kingdom)

JOI 国にはN 個の街があり，それらの間はM 本の双方向に通行可能な道路で結ばれている．国民は道路を通ってそれらの街を移動する．

JOI 国の国民には，お祭りが好きな人が多く，現在，K 個の街でお祭りが開催されており，非常に賑わっている．一方で，一部の国民はお祭りを騒がしいとして嫌い，お祭りにできるだけ近づきたくないと思っている．

そこで国王は，優秀なプログラマーであるあなたに，そのようなお祭りを嫌う国民のため，ある街からある街に移動するために，お祭りが開催されている街にどれだけ近づかずに移動することができるかを高速に調べることのできるプログラムの作成を依頼した．

課題

道路の情報とお祭りが開催されている街の情報，およびQ 個のクエリ（出発する街Si と行きたい街Tiの組）が与えられる．各クエリi に対し，街Si から街Ti へのすべての経路のうち，お祭りまでの距離が最大となる経路の，お祭りまでの距離を求めるプログラムを作成せよ．ただし，ある経路のお祭りまでの距離とは，経路上の街からお祭りが開催されている街までの移動距離の最小値のことである．

制限

2 ≤ N ≤ 100000 (= 105)     JOI 国の街の個数

1 ≤ M ≤ 200000 (= 2 × 105)     JOI 国の道路の本数

1 ≤ K ≤ N     お祭りが開催されている街の個数

1 ≤ Q ≤ 100000 (= 105)     クエリの個数

1 ≤ Li ≤ 1000     i 番目の道路の長さ

入力

標準入力から以下のデータを読み込め．

1 行目には整数N, M, K, Q が空白を区切りとして書かれている．N はJOI 国の街の個数を，M はJOI国の道路の本数を，K はお祭りが開催されている街の個数を，Q はクエリの個数をそれぞれ表す．街には1, 2, ... , N の番号がつけられている．

続くM 行は道路の情報を表す．i + 1 行目(1 ≤ i ≤ M) には整数Ai, Bi, Li (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N) が空白を区切りとして書かれている．これは，i 番目の道路が街Ai と街Bi を結んでおり，長さがLi であることを表す．道路の両端が同じ街であることはない．また，任意の2 つの街p, q に対し，p とqを結ぶ道路は2 本以上存在しない．どの街からどの街へもいくつかの道路をたどって行くことができる．

続くK 行はお祭りが開催されている街の情報を表す．i + M + 1 行目(1 ≤ i ≤ K) には1 つの整数Fi(1 ≤ Fi ≤ N) が書かれている．これは街Fi でお祭りが開催されていることを表す．F1, ..., FK の中に同じ値が2 回以上現れることはない．

続くQ 行はクエリを表す．i + M + K + 1 行目(1 ≤ i ≤ Q) には2 つの整数Si, Ti (1 ≤ Si ≤ N, 1 ≤ Ti ≤ N, Si ≠ Ti) が空白を区切りとして書かれている．これはi 番目のクエリの出発する街がSi であり行きたい街がTi であることを表す．

出力

標準出力に，全クエリへの答えをQ 行で出力せよ．すなわち，i 行目に，街Si から街Ti へのすべての経路のうち，お祭りまでの距離が最大となる経路の，お祭りまでの距離を表す整数を出力せよ．

採点基準

採点用データのうち，

配点の10% 分については，Q = 1 を満たす．

配点の20% 分については，N ≤ 5000, Q ≤ 5000 を満たす．

配点の30% 分については，これら2 つの条件の少なくとも一方を満たす．また，これら2 つの条件の両方を満たすような採点用データはない．

入出力例

入力例 1

6 6 2 3
1 2 5
2 3 4
2 4 6
3 5 9
4 5 3
5 6 7
1
6
3 4
5 2
1 4

出力例 1

7
5
0

6 つの街が6 本の道路で結ばれており，お祭りは街1, 6 の2 つの街で開催されている．クエリは以下の3 つである．

1 つ目のクエリは街3 から街4 へ行くというものである．街2 を経由する経路ではお祭りまでの距離は5，街5 を経由する経路ではお祭りまでの距離は7 となるため，答えは7 である．

2 つ目のクエリは街5 から街2 へ行くというものである．街3 と街4 のどちらを経由しても，街2 でお祭りまでの距離が最小となり，答えは5 である．

3 つ目のクエリは街1 から街4 へ行くというものである．街1 はお祭りが開催されている街であるため，答えは0 となる．

図1: 入力例1

入力例 2

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

出力例 2

8
8
11
0
6

図1: 入力例2

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in Rust (judge verdict: Accepted)

/**
 *  _           _                 __                            _   _ _   _                                 _                    _                  _
 * | |         | |               / /                           | | (_) | (_)                               | |                  (_)                | |
 * | |__   __ _| |_ ___   ___   / /__ ___  _ __ ___  _ __   ___| |_ _| |_ ___   _____ ______ _ __ _   _ ___| |_ ______ ___ _ __  _ _ __  _ __   ___| |_ ___
 * | '_ \ / _` | __/ _ \ / _ \ / / __/ _ \| '_ ` _ \| '_ \ / _ \ __| | __| \ \ / / _ \______| '__| | | / __| __|______/ __| '_ \| | '_ \| '_ \ / _ \ __/ __|
 * | | | | (_| | || (_) | (_) / / (_| (_) | | | | | | |_) |  __/ |_| | |_| |\ V /  __/      | |  | |_| \__ \ |_       \__ \ | | | | |_) | |_) |  __/ |_\__ \
 * |_| |_|\__,_|\__\___/ \___/_/ \___\___/|_| |_| |_| .__/ \___|\__|_|\__|_| \_/ \___|      |_|   \__,_|___/\__|      |___/_| |_|_| .__/| .__/ \___|\__|___/
 *                                                  | |                                                                           | |   | |
 *                                                  |_|                                                                           |_|   |_|
 *
 * https://github.com/hatoo/competitive-rust-snippets
 */
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};
mod util {
    use std::io::{stdin, stdout, BufWriter, StdoutLock};
    use std::str::FromStr;
    use std::fmt::Debug;
    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }
    #[allow(dead_code)]
    pub fn chars() -> Vec<char> {
        line().chars().collect()
    }
    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
    #[allow(dead_code)]
    pub fn with_bufwriter<F: FnOnce(BufWriter<StdoutLock>) -> ()>(f: F) {
        let out = stdout();
        let writer = BufWriter::new(out.lock());
        f(writer)
    }
}
#[allow(unused_macros)]
macro_rules ! get { ( $ t : ty ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . trim ( ) . parse ::<$ t > ( ) . unwrap ( ) } } ; ( $ ( $ t : ty ) ,* ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; let mut iter = line . split_whitespace ( ) ; ( $ ( iter . next ( ) . unwrap ( ) . parse ::<$ t > ( ) . unwrap ( ) , ) * ) } } ; ( $ t : ty ; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ ( $ t : ty ) ,*; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ ( $ t ) ,* ) ) . collect ::< Vec < _ >> ( ) } ; ( $ t : ty ;; ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . split_whitespace ( ) . map ( | t | t . parse ::<$ t > ( ) . unwrap ( ) ) . collect ::< Vec < _ >> ( ) } } ; ( $ t : ty ;; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ t ;; ) ) . collect ::< Vec < _ >> ( ) } ; }
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { println ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }
#[allow(dead_code)]
#[derive(Eq, PartialEq, Clone, Debug)]
/// Equivalent to std::cmp::Reverse
pub struct Rev<T>(pub T);
impl<T: PartialOrd> PartialOrd for Rev<T> {
    fn partial_cmp(&self, other: &Rev<T>) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }
}
impl<T: Ord> Ord for Rev<T> {
    fn cmp(&self, other: &Rev<T>) -> Ordering {
        other.0.cmp(&self.0)
    }
}

#[allow(dead_code)]
/// Union Find Tree
pub struct UFT {
    pub par: Vec<usize>,
    pub rank: Vec<usize>,
}
impl UFT {
    #[allow(dead_code)]
    pub fn new(n: usize) -> Self {
        UFT {
            par: (0..n).collect(),
            rank: vec![0; n],
        }
    }
    #[allow(dead_code)]
    pub fn find(&mut self, x: usize) -> usize {
        if self.par[x] == x {
            x
        } else {
            let p = self.par[x];
            let pp = self.find(p);
            self.par[x] = pp;
            pp
        }
    }
    #[allow(dead_code)]
    pub fn unite(&mut self, x: usize, y: usize) {
        let x = self.find(x);
        let y = self.find(y);
        if x == y {
            return;
        }
        if self.rank[x] < self.rank[y] {
            self.par[x] = y;
        } else {
            self.par[y] = x;
            if self.rank[x] == self.rank[y] {
                self.rank[x] += 1;
            }
        }
    }
}

#[allow(dead_code)]

pub const INF: u64 = 1 << 60;

fn main() {
    let (n, m, k, q) = get!(usize, usize, usize, usize);
    let abl = get!(usize, usize, u64; m);
    let fs = get!(usize; k);
    let st = get!(usize, usize; q);

    let mut g = vec![Vec::new(); n + 1];

    for &(a, b, l) in &abl {
        g[a].push((b, l));
        g[b].push((a, l));
    }

    let mut ds = vec![INF; n + 1];

    let mut heap = fs.into_iter()
        .map(|c| Rev((0, c)))
        .collect::<BinaryHeap<_>>();

    while let Some(Rev((d, i))) = heap.pop() {
        if ds[i] > d {
            ds[i] = d;

            for &(to, l) in &g[i] {
                if ds[to] > d + l {
                    heap.push(Rev((d + l, to)));
                }
            }
        }
    }

    let mut edges: Vec<(usize, usize, u64)> = abl.into_iter()
        .map(|(a, b, _l)| (a, b, min(ds[a], ds[b])))
        .collect();

    edges.sort_by_key(|&(_a, _b, c)| Rev(c));

    let mut ranges = vec![(0, m); q];
    let mut ans = vec![0; q];

    loop {
        let mut mids = vec![Vec::new(); m];

        let mut update = false;
        for (i, &(l, r)) in ranges.iter().enumerate() {
            if l != r {
                mids[(l + r) / 2].push(i);
                update = true;
            }
        }

        if !update {
            break;
        }

        let mut uft = UFT::new(n + 1);
        for (i, &(a, b, _c)) in edges.iter().enumerate() {
            uft.unite(a, b);

            for &k in &mids[i] {
                if uft.find(st[k].0) == uft.find(st[k].1) {
                    ranges[k].1 = i;
                } else {
                    ranges[k].0 = i + 1;
                }

                if ranges[k].0 == ranges[k].1 {
                    ans[k] = edges[ranges[k].0].2;
                }
            }
        }
    }

    util::with_bufwriter(|mut out| {
        for (a, (s, t)) in ans.into_iter().zip(st.into_iter()) {
            if s == t {
                writeln!(out, "{}", ds[s]).unwrap();
            } else {
                writeln!(out, "{}", a).unwrap();
            }
        }
    });
}