Problem:
Princess in Danger

お姫様の危機

English text is not available in this practice contest.

ある貧乏な国のおてんばで勇敢なお姫様が，政略結婚のため別の国に嫁ぐことになった．ところが，お姫様を亡き者としようとしている悪漢に嫁ぎ先への道中で襲われお姫様が大けがをしてしまい，近くの病院に搬送された．ところが，悪漢はお姫様は確実に亡き者とするため特殊な毒を使っていた．そのため，お姫様を助けるには本国から特別な薬と冷凍された肉親の血液を大急ぎで運ばなければならなくなった．

この血液は冷凍状態で輸送されるのだが，鮮度を保つため，前回の冷凍から最大 M 分以内に血液冷凍施設で再冷凍しなければならない．しかし，冷凍施設が設置されている場所は数カ所しかない．

血液は，十分に冷凍した状態から，再冷凍なしで M 分の間無事である．再冷凍しなくてすむ残り時間が S 分のときに，T 分間冷凍しないで輸送した場合，再冷凍しなくてすむ残り時間は S - T 分となる．再冷凍しなくてすむ残り時間は，再冷凍することにより，最大 M 分まで回復する．血液の再冷凍にかかる時間は，どれだけ冷凍するかに依存する．血液を冷凍施設で，1分冷凍するごとに再冷凍しなくてすむ残り時間は1分回復する．

本国の首都を出発する時点の，血液を再冷凍しなくてすむ残り時間はM分である．

お姫様の従者であるあなたは，大切な主君の命を救うため，本国の首都からお姫様が搬送された病院まで血液の鮮度を保ったまま輸送するための経路を計算しなければならない．そう，あなたの使命は，本国の首都からその病院への最短経路を割り出し，その最短時間を求めることである．

Input

入力は，複数のデータセットより構成される．各データセットの最初の行には，6 つの非負の整数 N(2 ≦ N ≦ 100)，M(1 ≦ M ≦ 100)，L(0 ≦ L ≦ N - 2)，K，A(0 ≦ A ＜ N)，H(0 ≦ H ＜ N) が与えられる．これらはそれぞれ，町の数，再冷凍を行うまでの制限時間，冷凍施設のある町の数，町と町を直接結ぶ道路の数，本国の首都を表す番号，お姫様が搬送された病院のある町の番号を表す．本国の首都とお姫様が搬送された病院は，異なる町である．なお，町には 0 〜 N-1 までの番号がそれぞれ割り当てられているものとする．続く行には，L 個の非負の整数が 1 つの空白で区切られて与えられる．これらは，冷凍施設がある町の番号を表す．なお，本国の首都とお姫様が搬送された病院はこのリストには含まれないが，冷凍施設があるものと考えて良い．続く K 行では，町と町を結ぶ道路の情報が与えられる．その第 i 行目では，3 つの非負の整数 X ，Y ，T が 1 つの空白で区切られて与えられ，これは町 X と町 Y を直接結ぶ道があり，移動には時間 T を要するということを表す．なお，この道は双方向に通行可能である．また，町Xと町Yを直接結ぶ道は高々一つしか無い．

入力は N = M = L = K = A = H = 0 の時に終了し，これはデータセットに含まれない．

Output

各データセットについて，鮮度を保ったまま血液を届けることができる最短時間を出力せよ．もし届けることができない場合には "Help!" と出力せよ．

Sample Input

2 1 0 1 0 1
0 1 2
3 1 1 2 0 1
2
0 2 1
1 2 1
3 2 1 2 0 1
2
0 2 1
1 2 1
4 4 1 4 1 3
2
0 1 2
1 2 4
0 2 1
3 0 3
5 3 2 6 0 3
1 2
2 1 2
1 0 1
3 4 1
2 4 1
4 1 2
2 0 2
5 4 2 6 0 3
1 2
4 2 4
2 1 2
4 3 1
0 1 5
1 4 2
2 0 3
0 0 0 0 0 0

Output for the Sample Input

Help!
3
2
10
5
12

Solution in JAVA (judge verdict: Memory Limit Exceeded)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;
 
public class Main {
    public static class Walk implements Comparable<Walk>{
        int pos, time, limit, max_limit;
 
        public Walk(int pos, int time, int limit, int max_limit) {
            super();
            this.pos = pos;
            this.time = time;
            this.limit = limit;
            this.max_limit = max_limit;
        }
 
        @Override
        public int compareTo(Walk o) {
            return this.time - o.time;
        }
    }
     
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        while (true) {
            final int N = sc.nextInt();
            final int M = sc.nextInt();
            final int L = sc.nextInt();
            final int K = sc.nextInt();
            final int A = sc.nextInt();
            final int H = sc.nextInt();
             
            if(N == 0 && M == 0 && L == 0 && K == 0 && A == 0 && H == 0){
                break;
            }
             
            System.gc();
            
            Set<Integer> cool = new HashSet<Integer>(L);
            ArrayList<Map<Integer, Integer>> a_list = new ArrayList<Map<Integer, Integer>>(N);
            for(int i = 0; i < N; i++){
                a_list.add(new HashMap<Integer, Integer>());
            }
             
            for(int i = 0; i < L; i++){
                cool.add(sc.nextInt());
            }
            cool.add(A);
            cool.add(H);
             
            for(int i = 0; i < K; i++){
                final int from = sc.nextInt();
                final int to = sc.nextInt();
                final int cost = sc.nextInt();
                 
                a_list.get(from).put(to, cost);
                a_list.get(to).put(from, cost);
            }
             
            boolean[][] is_visited = new boolean[N][M * 100 + 1];
            boolean[][] in_queue   = new boolean[N][M * 100 + 1];
             
            PriorityQueue<Walk> queue = new PriorityQueue<Walk>();
            queue.add(new Walk(A, 0, M, M));
             
            boolean flag = false;
            while(!queue.isEmpty()){
                Walk walk = queue.poll();
                 
                //System.out.println(walk.pos + " " + walk.time + " " + walk.limit);
                 
                in_queue[walk.pos][walk.max_limit] = false;
                if(is_visited[walk.pos][walk.max_limit]){
                    continue;
                }else{
                    is_visited[walk.pos][walk.limit] = true;
                }
                 
                if(walk.pos == H){
                    System.out.println(walk.time - walk.max_limit);
                    flag = true;
                    break;
                }
                 
                for(Map.Entry<Integer, Integer> entry : a_list.get(walk.pos).entrySet()){
                    if(!cool.contains(walk.pos)){
                        if(walk.limit < entry.getValue()){
                            continue;
                        }else if(is_visited[entry.getKey()][walk.limit - entry.getValue()]){
                            continue;
                        }else if(in_queue[entry.getKey()][walk.limit - entry.getValue()]){
                            continue;
                        }else{
                            queue.add(new Walk(entry.getKey(), walk.time + entry.getValue(), walk.limit - entry.getValue(), walk.max_limit - entry.getValue()));
                        }
                    }else{/*
                        for(int rest = 0; rest <= M; rest++){
                            if(walk.limit + rest > M){
                                break;
                            }
                             
                            if(walk.limit + rest < entry.getValue()){
                                continue;
                            }else if(is_visited[entry.getKey()][walk.limit - entry.getValue() + rest]){
                                continue;
                            }else if(in_queue[entry.getKey()][walk.limit - entry.getValue() + rest]){
                                continue;
                            }else{
                                queue.add(new Walk(entry.getKey(), walk.time + entry.getValue() + rest, walk.limit - entry.getValue() + rest));
                            }
                        }
                        */
                         
                        if(Math.min(walk.limit + M, M) < entry.getValue()){
                            continue;
                        }else if(is_visited[entry.getKey()][walk.limit - entry.getValue() + M]){
                            continue;
                        }else if(in_queue[entry.getKey()][walk.limit - entry.getValue() + M]){
                            continue;
                        }else{
                            queue.add(new Walk(entry.getKey(), walk.time + entry.getValue() + M, Math.min(M , walk.limit + M) - entry.getValue(), walk.max_limit - entry.getValue() + M));
                        }
                    }
                }
                 
            }
             
            if(!flag){
                System.out.println("help!");
            }
        }
 
        sc.close();
    }
 
}