Problem:
Problem D: Mr. Rito Post Office

あなたは離島の郵便局に勤めるプログラマである．あなたの住んでいる地域は，複数の島々からなる．各島には一つ以上の港町がある．それらに加えて他の町や村があるかもしない．ある島から別の島に向かうためには船を使わなければならない．一つの島の中を回るには陸路が使えるが，海路を利用した方が速いこともある．

近年行われた郵便局の民営化をきっかけに，経費削減に向けて郵便配達員の人員整理が全国的に行われた．離島の郵便局もその例外ではなく，結果として郵便配達員は利藤さんただ一人となってしまった．その郵便局が集配を担当する地域は非常に広いため，一人で集配するのは大変な作業である．なので，どのようにすれば効率的に集配を行えるのか，利藤さんがあなたに助けを求めてきた．

あなたの仕事は，利藤さんがたどるべき町や村の集配順序が与えられたときに，最短巡回経路を求めるプログラムを書くことである．

利藤さんは，決して指定された順序以外で集配業務を行うことができない．しかし，ある町や村から別の町や村へ移動する際に，他の町や村を経由して移動することは許可されている．また，利藤さんは島々を巡るための一隻の船を持っている．

例えば，町A，町B，村Cという集配順序が与えられた場合，町Aから町Bへ向かう際にどの町や村を経由してもかまわない．このとき，村Cを経由しても構わないが，集配順序を守るためには，一度町Bに行って集配をおこなってから，改めて村Cを訪れて集配をおこなわなければならない．また，町Aから海路を用いて町Bに向かい，町Bから陸路を用いて村Cに向かった場合，船を町Bに置いたままになる．したがって，次に海路を使いたい場合は町Bに戻る必要がある．

一つの町や村において複数回集配をしなければならない場合もある．たとえば，町A，村B，町C，村Bという集配順序が与えられるかもしれない．このとき，町Aから村Bをたどらずに町Cに向かった場合は，町Cでいきなり集配をおこなうことはできない．最初の村Bでの集配が終わっていないからである．町Cで集配を済ませた後で村Bを訪れて集配しても，一回目の村Bの集配を終わらせたことにはならない．

利藤さんは，はじめに必ずある港町に船とともにいる．利藤さんはベテランであるため，移動時間以外の集配作業にかかる時間は無視してよい．また，最後の町または村での集配業務が完了するまでの時間だけが問題であり，船をもとの位置に戻して郵便局に帰るまでの時間は考慮しなくてよい．

Input

入力は複数のデータセットから構成される．各データセットの形式は次に示すとおりである．

N M

x1 y1 t1 sl1

x2 y2 t2 sl2

...

xM yM tM slM

R

z1 z2 ... zR

データセットの中の入力項目は，すべて非負の整数である．行中の入力項目の区切りは空白 1 個である．

最初の行は，陸路及び海路網の大きさを規定する．

N (2 ≤ N ≤ 200) は，町または村の数である．
それぞれの町または村には，1 から N までの固有の番号を割り当てる．
M (1 ≤ M ≤ 10000) は，陸路と海路の合計本数である．

2 行目から 1 + M 行目は，陸路または海路の記述である．
xi と yi (1 ≤ xi, yi ≤ N) は両端の町または村の番号を表す．
ti (1 ≤ ti ≤ 1000) はその陸路または海路の移動時間を表す．
sli は ‘L’ または ‘S’ のいずれかであり，Lは陸路を，Sは海路をそれぞれ表す．

ある2つの町や村を直接結ぶ陸路または海路が2本以上存在することがある． それぞれの陸路または海路は双方向であり，すなわちどちらの向きにも移動できる．

M + 2 行目の R (1 ≤ R ≤
1000)は，利藤さんが担当する集配先の数を表す． M + 3 行目には，集配先の町や村の番号 zi (1 ≤ zi ≤ N) が集配順に R 個並んでいる．

初期状態では利藤さんと船はともに港町 z1 に存在する． 初期状態から集配先の町や村へは，必ず何らかの方法で移動することができる．

入力の終わりは，空白で区切られた2つの0を含む1行で示される．

Output

入力の各データセットに対して，与えられた集配順序で利藤さんが町と村を巡回するために必要な最短移動時間を求め，1行に出力せよ．

Sample Input

3 3
1 2 5 L
1 2 7 S
2 3 11 S
3
1 2 3
5 5
1 2 15 L
2 3 10 L
4 5 7 L
1 3 30 S
3 4 100 S
5
1 3 5 4 1
0 0

Output for the Sample Input

18
269

Solution in JAVA (judge verdict: Wrong Answer)


import java.lang.reflect.Array;
import java.util.*;
import java.util.Map.Entry;
import static java.lang.Math.*;
import static java.lang.System.*;

class Main {
	public static Scanner sc = new Scanner(in);
	//public static Random rand=new Random();

	static final int INF =1<<28;

	static class Node{
		int id;
		List<Edge> link=new LinkedList<Edge>();
		Node(int _id){
			id=_id;
		}
	}
	static class Edge{
		int from,to;
		int cost;
		Edge(int _from,int _to,int _cost){
			from=_from;to=_to;cost=_cost;
		}
		public String toString() {
			return from+"->"+to;
		}
	}
	static class Task implements Comparable<Task>{
		int prev,pos;
		int cost;
		Task(int _prev,int _pos,int _cost){
			prev=_prev;pos=_pos;cost=_cost;
		}
		@Override
		public int compareTo(Task T) {
			return cost>T.cost?1:cost<T.cost?-1:0;
		}
	}

	public int[] dijkstra(Node[] graph,int s,int[] prev){
		final int V=graph.length;
		int[] d=new int[V];Arrays.fill(d,INF);d[s]=0;
		Arrays.fill(prev,-2);
		PriorityQueue<Task> que=new PriorityQueue<Task>();
		que.add(new Task(-1,s,0));
		while(!que.isEmpty()){
			Task task=que.poll();
			if(prev[task.pos]!=-2)continue;
			//if(d[task.pos]<task.cost)continue;
			prev[task.pos]=task.prev;
			for(Edge e:graph[task.pos].link){
				//if(decV(task.prev)==decV(e.to))continue;
				if(d[e.to]>d[e.from]+e.cost){
					d[e.to]=d[e.from]+e.cost;
					que.add(new Task(e.from,e.to,d[e.to]));
				}
			}
		}
		return d;
	}

	public int enc(int v,int prev,int l){
		return N*(L+1)*v+prev*(L+1)+l;
	}
	public int decL(int id){
		return id%(L+1);
	}
	public int decV(int id){
		return id/(L+1);
	}
	void warshall_floyd(int[][] d){
		final int V=d.length;
		int[][] prev=new int[V][V];
	    for(int k=0;k<V;k++)
	    	for(int i=0;i<V;i++)for(int j=0;j<V;j++)
	    		if(d[i][j]>d[i][k] + d[k][j]){
	    			d[i][j]=d[i][k] + d[k][j];
	    			prev[i][j]=k;
	    		}
	}

	int N,M,L;
	public void run() {
		TCase:while(true){
			N=sc.nextInt();M=sc.nextInt();
			if(N==0)return;
			int[][] ld=new int[N][N];
			for(int i=0;i<N;i++)for(int j=0;j<N;j++)
				ld[i][j]=INF;
			for(int i=0;i<N;i++)ld[i][i]=0;
			int[][] sd=new int[N][N];
			for(int i=0;i<N;i++)for(int j=0;j<N;j++)
				sd[i][j]=INF;
			for(int i=0;i<N;i++)sd[i][i]=0;
			for(int i=0;i<M;i++){
				int x=sc.nextInt()-1,y=sc.nextInt()-1,t=sc.nextInt();
				char sl=sc.next().charAt(0);
				if(sl=='L'){
					ld[x][y]=ld[y][x]=t;
				}else{
					sd[x][y]=sd[y][x]=t;
				}
			}
			warshall_floyd(ld);
			warshall_floyd(sd);


			int R=sc.nextInt();
			int[] zs=new int[R];
			for(int i=0;i<R;i++)zs[i]=sc.nextInt()-1;

			int[] dp=new int[N];//sip pos
			Arrays.fill(dp,INF);
			dp[zs[0]]=0;
			for(int i=1;i<R;i++){
				int[] tmp=new int[N];
				for(int j=0;j<N;j++)
					tmp[j]=min(tmp[j],dp[j]+ld[zs[i-1]][zs[i]]);
				for(int j=0;j<N;j++){
					for(int k=0;k<N;k++){
						tmp[j]=min(tmp[j],dp[k]+ld[zs[i-1]][k]+sd[k][j]+ld[j][zs[i]]);
					}
					tmp[j]=min(tmp[j],dp[j]+ld[zs[i-1]][zs[i]]);
				}
				dp=tmp;
				//ln(str(dp));
			}
			int mv=INF;
			for(int i=0;i<N;i++)
				mv=min(mv,dp[i]);

			ln(mv);
		}
	}

	public String strPath(List<Integer> path){
		String res="";
		for(Integer v:path){
			res+="("+decV(v)+","+decL(v)+")--";
		}
		return res;
	}
	//パスの出力
	public static List<Integer> path(int[] prev,int e){
		List<Integer> path=new ArrayList<Integer>();
		for (int u = e; u >= 0; u = prev[u])
			path.add(u);
		Collections.reverse(path);
		return path;
	}

	public static void main(String[] args) {
		new Main().run();
	}

	//output lib
	static final String br=System.getProperty("line.separator");
	static final String[] asep=new String[]{""," ",br,br+br};
	static String str(Boolean o){
		return o?"YES":"NO";
	}
//	static String str(Double o){
//		return String.format("%.8f",o);
//	}
	static <K,V> String str(Map<K, V> map){
		StringBuilder sb=new StringBuilder();
		boolean isFirst=true;
		for(Entry<K,V> set:map.entrySet()){
			if(!isFirst)sb.append(br);
			sb.append(str(set.getKey())).append(":").append(str(set.getValue()));
			isFirst=false;
		}
		return sb.toString();
	}
	static <E> String str(Collection<E> list){
		StringBuilder sb=new StringBuilder();
		boolean isFirst=true;
		for(E e:list){
			if(!isFirst)sb.append(" ");
			sb.append(str(e));
			isFirst=false;
		}
		return sb.toString();
	}

	static String str(Object o){
		int depth=_getArrayDepth(o);
		if(depth>0)return _strArray(o,depth);
		Class<?> c=o.getClass();
		if(c.equals(Boolean.class))return str((Boolean)o);
		//if(c.equals(Double.class))return str((Double)o);

		return o.toString();
	}
	static int _getArrayDepth(Object o){
		if(!o.getClass().isArray() || Array.getLength(o)==0) return 0;
		return 	1+_getArrayDepth(Array.get(o,0));
	}
	static String _strArray(Object o,int depth){
		if(depth==0) return str(o);
		StringBuilder sb=new StringBuilder();
		for(int i=0,len=Array.getLength(o);i<len;i++){
			if(i!=0)sb.append(asep[depth]);
			sb.append(_strArray(Array.get(o,i),depth-1));
		}
		return sb.toString();
	}
	static void pr(Object... os){
		boolean isFirst=true;
		for(Object o:os){
			if(!isFirst)out.print(" ");
			out.print(o);
			isFirst=false;
		}
	}
	static void ln(){
		out.println();
	}
	static void ln(Object... os){
		for(Object o:os){
			pr(o);ln();
		}
	}
}