Problem:
Score : 400 points

Problem Statement

There are N towns in the State of Atcoder, connected by M bidirectional roads.

The i-th road connects Town A_i and B_i and has a length of C_i.

Joisino is visiting R towns in the state, r_1,r_2,..,r_R (not necessarily in this order).

She will fly to the first town she visits, and fly back from the last town she visits, but for the rest of the trip she will have to travel by road.

If she visits the towns in the order that minimizes the distance traveled by road, what will that distance be?

Constraints

2≤N≤200

1≤M≤N×(N-1)/2

2≤R≤min(8,N) (min(8,N) is the smaller of 8 and N.)

r_i≠r_j (i≠j)

1≤A_i,B_i≤N, A_i≠B_i

(A_i,B_i)≠(A_j,B_j),(A_i,B_i)≠(B_j,A_j) (i≠j)

1≤C_i≤100000

Every town can be reached from every town by road.

All input values are integers.

Input

Input is given from Standard Input in the following format:

N M R
r_1 ... r_R
A_1 B_1 C_1
:
A_M B_M C_M

Output

Print the distance traveled by road if Joisino visits the towns in the order that minimizes it.

Sample Input 1

3 3 3
1 2 3
1 2 1
2 3 1
3 1 4

Sample Output 1

2

For example, if she visits the towns in the order of 1, 2, 3, the distance traveled will be 2, which is the minimum possible.

Sample Input 2

3 3 2
1 3
2 3 2
1 3 6
1 2 2

Sample Output 2

4

The shortest distance between Towns 1 and 3 is 4. Thus, whether she visits Town 1 or 3 first, the distance traveled will be 4.

Sample Input 3

4 6 3
2 3 4
1 2 4
2 3 3
4 3 1
1 4 1
4 2 2
3 1 6

Sample Output 3

3

Solution in C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using static System.Console;
using static System.Math;
 
public class Solve{
    static public int mod = 1000000007;
    static public string al = "abcdefghijklmnopqrstuvwxyz";
    public static void Main(){
        // •ûj
        // 
        var tn = inta();
        var n = tn[0];
        var m = tn[1];
        var r = tn[2];
        var distance = new int[n,n];
        var list = inta();
        for(int i=0;i<r;i++){
            list[i]--;
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i == j) continue;
                distance[i,j] = 200000000;
            }
        }
        for(int i=0;i<m;i++){
            var temp = inta();
            var t1 = temp[0]-1;
            var t2 = temp[1]-1;
            var leng = temp[2];
            distance[t1,t2] = leng;
            distance[t2,t1] = leng;
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++){
                    distance[i,j] = Min(distance[i,j], distance[i,k] + distance[k,j]);
                }
            }
        }
        
        var minlength = 1000000000;
        var per = new Permutation(r);
        while(true){
            var turn = per.now();
            var length = 0;
            for(int i=0;i<r-1;i++){
                var before = list[turn[i]];
                //WriteLine(turn[i+1]);
                var after = list[turn[i+1]];
                //WriteLine($"{before} {after} {distance[before,after]}");
                length += distance[before,after];
            }
            //WriteLine(length);
            minlength = Min(minlength,length);
            if(!per.next()) break;
        }
        
        WriteLine(minlength);
        
	
	
    }
    public static void swap(ref int a,ref int b){int temp = a;a= b;b = temp;}
    static void charswap(ref char a,ref char b){char temp = a;a= b;b = temp;}
    static int ncr(int n,int r){if(n<r)return 0;r = Min(r,n-r);long nn = 1;for(int i=n-r+1;i<=n;i++){nn = nn*i%mod;}long rr = 1;for(int i=1;i<=r;i++){rr = rr*i%mod;}rr = square((int)rr,mod-2);nn = nn * rr %mod;return (int)nn;}
    // a^b mod
    static int square(int a,int b){string binary = Convert.ToString(b,2);int bileng = binary.Length;long a_power = a;long value = 1;for(int i=bileng-1;i>=0;i--){if(binary[i] == '1'){value = value*a_power%mod;}a_power = a_power*a_power%mod;}return (int)value;}
    static int square2(int a,int b){long output = 1;var list = new List<long>();int sh = 1;long n = a;list.Add(a);while(sh < b){sh *= 2;n = n*n%mod;list.Add(n);}for(int i=list.Count-1;i>=0;i--){if(b > sh){b -= sh;sh /= 2;output = output*list[i]%mod;}}return (int)output;}
    //Šeí“Çæ
    static string rstr(){ return ReadLine(); }
    static int rint(){ return int.Parse(ReadLine()); }
    static long rlong(){ return long.Parse(ReadLine()); }
    static string[] stra(){ return ReadLine().Split(' '); }
    static char[] chara(){ string[] a=stra();string b="";for(int i=0;i<a.Length;i++){b+=a[i];}return b.ToCharArray();}
    static int[] inta(){ string[] read_str_array = ReadLine().Split(' '); int[] return_int_array = new int[read_str_array.Length]; for(int countup_i=0;countup_i<read_str_array.Length;countup_i++){ return_int_array[countup_i] = int.Parse(read_str_array[countup_i]); } return return_int_array; }
    static int[,] inta2(int num_array,int in_array){ int[,] int_array2 = new int[num_array,in_array]; for(int i=0;i<num_array;i++){ int[] temp_array = inta(); for(int j=0;j<in_array;j++){ int_array2[i,j] = temp_array[j]; } } return int_array2; }
    static long[] longa(){ string[] read_str_array = ReadLine().Split(' '); long[] return_long_array = new long[read_str_array.Length]; for(long countup_i=0;countup_i<read_str_array.Length;countup_i++){ return_long_array[countup_i] = long.Parse(read_str_array[countup_i]); } return return_long_array; }
    static double[] doublea(){ string[] read_str_array = ReadLine().Split(' '); double[] return_double_array = new double[read_str_array.Length]; for(long countup_i=0;countup_i<read_str_array.Length;countup_i++){ return_double_array[countup_i] = double.Parse(read_str_array[countup_i]); } return return_double_array; }
    // -----------------------------
    static long GCD(long a,long b){ if(a < b){ long temp = a; a = b; b = temp; } if(a % b == 0){ return b; } else{ long temp = b; b = a%b; a = temp; return GCD(a,b); } }
    static long LCM(long a,long b){ return a * b / GCD(a,b); }
    static void WriteArray(int[,] a,int b,int c){for(int i=0;i<b;i++){for(int j=0;j<c;j++){if(j!=0) Write(" ");Write(a[i,j]);}WriteLine();}}
}

class UnionFind{
    private int[] _unionfind;
    private int[] _unionfind_size;
    
    public UnionFind(int a){
        _unionfind = new int[a];
        _unionfind_size = new int[a];
        for(int i=0;i<a;i++){
            _unionfind[i] = i;
            _unionfind_size[i] = 1;
        }
    }
    
    public int root(int x){
        if(_unionfind[x] == x) return x;
        return _unionfind[x] = root(_unionfind[x]);
    }
    
    public void unite(int a,int b){
        a = root(a);
        b = root(b);
        if(a == b) return;
        if(_unionfind_size[a] < _unionfind_size[b]){
            int temp = a;
            a = b;
            b = temp;
        }
        _unionfind[b] = a;
        _unionfind_size[a] += _unionfind_size[b];
    }
    
    public bool same(int a,int b){
        return root(a) == root(b);
    }
    
    public int size(int x){
        return _unionfind_size[root(x)];
    }
}

class PriorityQueue{
    private List<int> _priorityqueue = new List<int>();
    
    public void Enqueue(int a){
        _priorityqueue.Add(a);
        int num = _priorityqueue.Count-1;
        while(true){
            if(num == 0) break;
            if(_priorityqueue[(num-1)/2] < _priorityqueue[num]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                int temp = _priorityqueue[(num-1)/2];
                _priorityqueue[(num-1)/2] = _priorityqueue[num];
                _priorityqueue[num] = temp;
                num = (num-1)/2;
            }else{
                break;
            }
        }
    }
    
    public int Dequeue(){
        int re = _priorityqueue[0];
        int temp = _priorityqueue[0];
        _priorityqueue[0] = _priorityqueue[_priorityqueue.Count-1];
        _priorityqueue[_priorityqueue.Count-1] = temp;
        _priorityqueue.RemoveAt(_priorityqueue.Count-1);
        int num = 0;
        while(true){
            int swapnum = -1;
            if((num+1)*2 < _priorityqueue.Count){
                if(_priorityqueue[num*2+1] > _priorityqueue[(num+1)*2]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                    swapnum = num*2+1;
                }else{
                    swapnum = (num+1)*2;
                }
            }else if(num*2+1 < _priorityqueue.Count){
                swapnum = num*2+1;
            }
            if(swapnum == -1) break;
            if(_priorityqueue[swapnum] > _priorityqueue[num]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                temp = _priorityqueue[swapnum];
                _priorityqueue[swapnum] = _priorityqueue[num];
                _priorityqueue[num] = temp;
                num = swapnum;
            }else{
                break;
            }
        }
        return re;
    }
    
    public int Peek(){
        return _priorityqueue[0];
    }
    
    public int Count(){
        return _priorityqueue.Count;
    }
}
class PriorityQueue2{
    private List<int> _priorityqueue = new List<int>();
    private List<int> _accompany_info = new List<int>();
    
    public void Enqueue(int a,int b){
        _priorityqueue.Add(a);
        _accompany_info.Add(b);
        int num = _priorityqueue.Count-1;
        while(true){
            if(num == 0) break;
            if(_priorityqueue[(num-1)/2] > _priorityqueue[num]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                int temp = _priorityqueue[(num-1)/2];
                  _priorityqueue[(num-1)/2] = _priorityqueue[num];
                  _priorityqueue[num] = temp;
                temp = _accompany_info[(num-1)/2];
                  _accompany_info[(num-1)/2] = _accompany_info[num];
                  _accompany_info[num] = temp;
                num = (num-1)/2;
            }else{
                break;
            }
        }
    }
    
    public int[] Dequeue(){
        var re = new int[]{_priorityqueue[0],_accompany_info[0]};
        var qcount = _priorityqueue.Count;
        var temp = _priorityqueue[0]; _priorityqueue[0] = _priorityqueue[qcount-1]; _priorityqueue[qcount-1] = temp;
        temp = _accompany_info[0]; _accompany_info[0] = _accompany_info[qcount-1]; _accompany_info[qcount-1] = temp;
        _priorityqueue.RemoveAt(qcount-1);
        _accompany_info.RemoveAt(qcount-1);
        int num = 0;
        while(true){
            int swapnum = -1;
            if((num+1)*2 < _priorityqueue.Count){
                if(_priorityqueue[num*2+1] < _priorityqueue[(num+1)*2]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                    swapnum = num*2+1;
                }else{
                    swapnum = (num+1)*2;
                }
            }else if(num*2+1 < _priorityqueue.Count){
                swapnum = num*2+1;
            }
            if(swapnum == -1) break;
            if(_priorityqueue[swapnum] < _priorityqueue[num]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                temp = _priorityqueue[swapnum];_priorityqueue[swapnum] = _priorityqueue[num];_priorityqueue[num] = temp;
                temp = _accompany_info[swapnum];_accompany_info[swapnum] = _accompany_info[num];_accompany_info[num] = temp;
                num = swapnum;
            }else{
                break;
            }
        }
        return re;
    }
    
    public int[] Peek(){
        var temp = new int[]{_priorityqueue[0],_accompany_info[0]};
        return temp;
    }
    
    public int Count(){
        return _priorityqueue.Count;
    }
}
class PriorityQueue3{
    private List<int> _priorityqueue = new List<int>();
    private List<int> _accompany_info = new List<int>();
    private List<int> _accompany_info2 = new List<int>();
    
    public void Enqueue(int a,int b,int c){
        _priorityqueue.Add(a);
        _accompany_info.Add(b);
        _accompany_info2.Add(c);
        int num = _priorityqueue.Count-1;
        while(true){
            if(num == 0) break;
            if(_priorityqueue[(num-1)/2] > _priorityqueue[num]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                int temp = _priorityqueue[(num-1)/2];
                  _priorityqueue[(num-1)/2] = _priorityqueue[num];
                  _priorityqueue[num] = temp;
                temp = _accompany_info[(num-1)/2];
                  _accompany_info[(num-1)/2] = _accompany_info[num];
                  _accompany_info[num] = temp;
                  temp = _accompany_info2[(num-1)/2];
                  _accompany_info2[(num-1)/2] = _accompany_info2[num];
                  _accompany_info2[num] = temp;
                num = (num-1)/2;
            }else{
                break;
            }
        }
    }
    
    public int[] Dequeue(){
        var re = new int[]{_priorityqueue[0],_accompany_info[0],_accompany_info2[0]};
        var qcount = _priorityqueue.Count;
        var temp = _priorityqueue[0]; _priorityqueue[0] = _priorityqueue[qcount-1]; _priorityqueue[qcount-1] = temp;
        temp = _accompany_info[0]; _accompany_info[0] = _accompany_info[qcount-1]; _accompany_info[qcount-1] = temp;
        temp = _accompany_info2[0]; _accompany_info2[0] = _accompany_info2[qcount-1]; _accompany_info2[qcount-1] = temp;
        _priorityqueue.RemoveAt(qcount-1);
        _accompany_info.RemoveAt(qcount-1);
        _accompany_info2.RemoveAt(qcount-1);
        int num = 0;
        while(true){
            int swapnum = -1;
            if((num+1)*2 < _priorityqueue.Count){
                if(_priorityqueue[num*2+1] < _priorityqueue[(num+1)*2]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                    swapnum = num*2+1;
                }else{
                    swapnum = (num+1)*2;
                }
            }else if(num*2+1 < _priorityqueue.Count){
                swapnum = num*2+1;
            }
            if(swapnum == -1) break;
            if(_priorityqueue[swapnum] < _priorityqueue[num]){ //‘å¬‹t‚Ì˜M‚é‚Æ‚±
                temp = _priorityqueue[swapnum];_priorityqueue[swapnum] = _priorityqueue[num];_priorityqueue[num] = temp;
                temp = _accompany_info[swapnum];_accompany_info[swapnum] = _accompany_info[num];_accompany_info[num] = temp;
                temp = _accompany_info2[swapnum];_accompany_info2[swapnum] = _accompany_info2[num];_accompany_info2[num] = temp;
                num = swapnum;
            }else{
                break;
            }
        }
        return re;
    }
    
    public int[] Peek(){
        var temp = new int[]{_priorityqueue[0],_accompany_info[0],_accompany_info2[0]};
        return temp;
    }
    
    public int Count(){
        return _priorityqueue.Count;
    }
}

class Permutation{
    private int[] _permutation;
    private int _length;
    
    public Permutation(int a){
        _permutation = new int[a];
        for(int i=0;i<a;i++){
            _permutation[i] = i;
        }
        _length = a;
    }
    public int[] now(){
        return _permutation;
    }
    
    public bool next(){
        var upper = -1;
        for(int i=0;i<_length-1;i++){
            if(_permutation[i] < _permutation[i+1]) upper = i;
        }
        if(upper == -1){
            return false;
        }
        var bigger = -1;
        for(int i=upper;i<_length;i++){
            if(_permutation[upper] <= _permutation[i]) bigger = i;
        }
        var temp = _permutation[upper];
        _permutation[upper] = _permutation[bigger];
        _permutation[bigger] = temp;
        var list = new List<int>();
        upper++;
        for(int i=upper;i<_length;i++){
            list.Add(_permutation[i]);
        }
        list.Reverse();
        for(int i=upper;i<_length;i++){
            _permutation[i] = list[i-upper];
        }
        return true;
    }
    
    public void prev0(){
        Array.Reverse(_permutation);
    }
    
    public bool prev(){
        var lower = -1;
        for(int i=0;i<_length-1;i++){
            if(_permutation[i] > _permutation[i+1]) lower = i;
        }
        if(lower == -1){
            return false;
        }
        var smaller = -1;
        for(int i=lower;i<_length;i++){
            if(_permutation[lower] >= _permutation[i]) smaller = i;
        }
        var temp = _permutation[lower];
        _permutation[lower] = _permutation[smaller];
        _permutation[smaller] = temp;
        var list = new List<int>();
        lower++;
        for(int i=lower;i<_length;i++){
            list.Add(_permutation[i]);
        }
        list.Reverse();
        for(int i=lower;i<_length;i++){
            _permutation[i] = list[i-lower];
        }
        return true;
    }
}