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.Generic;
using static Assistant.Input;
using static Assistant.Debug;
using System.Linq;
using Assistant;

namespace ABC073D
{
    class Program
    {
        static void Main(string[] args)
        {
            var N = RInt;
            var M = RInt;
            var R = RInt;

            var r = RInts.Select(x => x - 1).ToArray();

            WarshallFloyd wf = new WarshallFloyd(N);
            for (int i = 0; i < M; i++)
            {
                int a = RInt - 1;
                int b = RInt - 1;
                int c = RInt;
                wf.AddEdge(a, b, c);
                wf.AddEdge(b, a, c);
            }

            bool negative;
            var dist = wf.Start(out negative);

            Draw2D(dist);

            long[,] dForTsp = new long[R, R];
            for (int i = 0; i < R; i++)
            {
                for (int j = 0; j < R; j++)
                {
                    dForTsp[i, j] = dist[r[i], r[j]];
                }
            }

            long minDist = long.MaxValue;
            for (int i = 0; i < R; i++)
            {
                V = R;
                d = dForTsp;
                dp = new long[1 << R, R];
                var cand = Tsp(1 << i, i);
                minDist = Math.Min(cand, minDist);
            }
            long ans = minDist;
            Console.WriteLine(ans);
        }

        static int V;     //頂点数
        static long[,] d; //頂点行列 頂点ない部分はlong.MaxValue / 4で初期化
        static long[,] dp; //DP
        static long INF = long.MaxValue / 2;
        /// <summary>
        /// 巡回セールスマン問題
        /// </summary>
        /// <param name="S">bit訪れた場所のbit</param>
        /// <param name="v">現在の頂点</param>
        /// <returns></returns>
        static long Tsp(int S = 1, int v = 0)
        {
            if (dp[S, v] != 0) return dp[S, v];
            if (S == (1 << V) - 1) return d[v, 0];

            long ret = INF;
            for (int i = 0; i < V; i++)
            {
                if ((S & (1 << i)) > 0) continue;
                if (d[v, i] == INF) continue;
                ret = Math.Min(ret, d[v, i] + Tsp(S | (1 << i), i));
            }

            return dp[S, v] = ret;
        }
    }


    /// <summary>
    /// 全頂点間距離 負の辺に対応、O(V^3)
    /// </summary>
    class WarshallFloyd
    {
        long INF = long.MaxValue;

        int _v;
        long[,] dp;

        public WarshallFloyd(int V)
        {
            _v = V;

            dp = new long[V, V];
            for (int i = 0; i < V; i++)
            {
                for (int j = 0; j < V; j++)
                {
                    if (i != j) dp[i, j] = INF;
                }
            }
        }

        public void AddEdge(int from, int to, long cost)
        {
            dp[from, to] = cost;
        }

        public long[,] Start(out bool negativeCycle)
        {
            negativeCycle = false;
            for (int k = 0; k < _v; k++)
            {
                for (int i = 0; i < _v; i++)
                {
                    for (int j = 0; j < _v; j++)
                    {
                        if (dp[i, k] == long.MaxValue || dp[k, j] == long.MaxValue) continue;
                        dp[i, j] = Math.Min(dp[i, j], dp[i, k] + dp[k, j]);
                    }

                    if (dp[i, i] < 0) negativeCycle = true;
                }
            }

            return dp;
        }

        public long Distance(int from, int to)
        {
            return dp[from, to];
        }
    }
}

namespace Assistant
{
    static class Input
    {
        static List<string> line = new List<string>();
        static int index = 0;
        static String RNext()
        {
            if (line.Count <= index) line.AddRange(Console.ReadLine().Split());
            return line[index++];
        }
        public static int RInt => int.Parse(RNext());
        public static long RLong => long.Parse(RNext());
        public static int[] RInts => Console.ReadLine().Split().Select(int.Parse).ToArray();
        public static long[] RLongs => Console.ReadLine().Split().Select(long.Parse).ToArray();
        public static string RString => RNext();
        //以下未テスト
        public static int[] RIntsC(int c) => Enumerable.Repeat(0, c).Select(x => int.Parse(RNext())).ToArray();
        public static long[] RLongsC(int c) => Enumerable.Repeat(0, c).Select(x => long.Parse(RNext())).ToArray();
        public static char[][] RMap(int h) => Enumerable.Repeat(0, h).Select(x => Console.ReadLine().ToCharArray()).ToArray();
    }

    public struct Mlong
    {
        long _v;
        const long mod = 1000000007;
        public Mlong(long n = 0) : this() { _v = n >= mod ? n % mod : n; }

        public static implicit operator Mlong(long _x) => new Mlong(_x);
        public static implicit operator long(Mlong _x) => _x._v;
        public static Mlong operator +(Mlong m1, Mlong m2) { long m = m1._v + m2._v; return m >= mod ? m - mod : m; }
        public static Mlong operator -(Mlong m1, Mlong m2) { long m = m1._v - m2._v; return m >= 0 ? m : m + mod; }
        public static Mlong operator *(Mlong m1, Mlong m2) => m1._v * m2._v % mod;
        public static Mlong operator /(Mlong m1, Mlong m2) => m1._v * ModPow(m2._v, mod - 2) % mod;

        public static long ModPow(long a, long n)
        {
            if (n == 0) return 1;
            else if (n % 2 == 1) return a * ModPow(a, n - 1) % mod;
            else return ModPow(a * a, n / 2);
        }

        static Mlong[] fac, finv, inv;
        public static void nCkInit(int max)
        {
            fac = new Mlong[max]; finv = new Mlong[max]; inv = new Mlong[max];
            fac[0] = fac[1] = 1;
            finv[0] = finv[1] = 1;
            inv[1] = 1;
            for (int i = 2; i < max; i++)
            {
                fac[i] = fac[i - 1] * i;
                inv[i] = mod - inv[mod % i] * (mod / i);
                finv[i] = finv[i - 1] * inv[i];
            }
        }

        public static Mlong nCk(int n, int k)
        {
            if (n < k) return 0;
            if (n < 0 || k < 0) return 0;
            return fac[n] * finv[k] * finv[n - k];
        }
    }

    static class Debug
    {
        static public void Draw2D<T>(T[,] map, int mode = 1)
        {
#if DEBUG
            int W = map.GetLength(0);
            int H = map.GetLength(1);

            string[,] map2 = new string[W + 1, H + 1];
            for (int i = 0; i < W + 1; i++)
            {
                for (int j = 0; j < H + 1; j++)
                {
                    if (i == 0 && j == 0) map2[i, j] = 0.ToString();
                    else if (i == 0) map2[i, j] = (j - 1).ToString();
                    else if (j == 0) map2[i, j] = (i - 1).ToString();
                    else map2[i, j] = map[i - 1, j - 1].ToString();
                }
            }

            for (int i = 0; i < W + 1; i++)
            {
                for (int j = 0; j < H + 1; j++)
                {
                    if (mode == 0) Console.Write(map2[i, j].Last());
                    if (mode == 1) Console.Write(map2[i, j] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
#endif
        }

        public static void Draw1D<T>(T[] array, int mode = 0)
        {
#if DEBUG
            Console.WriteLine(string.Join(" ", array));
#endif
        }
    }
}