using System;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using static System.Console;
using static System.Math;

namespace NotFounds
{
    public class Program
    {
        public static void Main(string[] args)
        {
            new Program().Solve();
        }

        public void Solve()
        {
            var cin = new MyInputStream();

            var N = cin.ri();
            var M = cin.ri();
            var R = cin.ri();
            var r = new int[R];
          
            for (var i = 0; i < R; ++i)
                r[i] = cin.ri() - 1;
            
            const long INF = (long)1e12;
            var d = new long[N, N];
            for (var i = 0; i < N; ++i)
                for (var j = 0; j < N; ++j)
                    d[i, j] = INF;

            for (var i = 0; i < M; ++i)
            {
                var A = cin.ri() - 1;
                var B = cin.ri() - 1;
                var C = cin.ri();
                d[A, B] = C;
                d[B, A] = C;
            }
          
            // Warshall-Floyd
            for (var k = 0; k < N; ++k)
                for (var i = 0; i < N; ++i)
                    for (var j = 0; j < N; ++j)
                        if (d[i, j] > d[i, k] + d[k, j])
                            d[i, j] = d[i, k] + d[k, j];
          
            var ans = (long)INF;
            foreach (var p in r.Permutations())
            {
                var perm = p.ToList();
                var dist = 0L;
            	for (var i = 0; i < perm.Count - 1; ++i)
                	dist += d[perm[i], perm[i + 1]];
                if (ans > dist)
                  ans = dist;
            }
            WriteLine(ans.ToString());
        }
    }

    public class MyInputStream
    {
        private char separator = ' ';
        private Queue<string> inputStream;
        public MyInputStream(char separator = ' ')
        {
            this.separator = separator;
            inputStream = new Queue<string>();
        }

        public string Read()
        {
            if (inputStream.Count != 0) return inputStream.Dequeue();
            string[] tmp = Console.ReadLine().Trim().Split(separator);
            for (int i = 0; i < tmp.Length; i++)
            {
                inputStream.Enqueue(tmp[i]);
            }
            return inputStream.Dequeue();
        }
        public string ReadLine() => Console.ReadLine();
        public int ReadInt() => int.Parse(Read());
        public long ReadLong() => long.Parse(Read());
        public double ReadDouble() => double.Parse(Read());
        public string r() => Read();
        public int ri() => ReadInt();
        public long rl() => ReadLong();
        public double rd() => ReadDouble();
    }
  
    public static class MyExtentions
    {
        public static IEnumerable<IEnumerable<T>> Permutations<T>(this IEnumerable<T> source)
        {
            if (source.Count() != 0)
            {
                int index = 0;
                foreach (var item in source)
                {
                    var allOtherItems = source.RemoveAt(index++);
                    foreach (var permutation in allOtherItems.Permutations())
                    {
                        yield return new[] { item }.Concat(permutation);
                    }
                }
            }
            else { yield return new T[0]; }
        }

        public static IEnumerable<T> RemoveAt<T>(this IEnumerable<T> source, int indexToRemove)
        {
            int index = 0;
            foreach (T item in source)
                if (index++ != indexToRemove)
                    yield return item;
        }
    }
}


Measured memory_bytes: 17888