# -*- coding: utf-8 -*-



from itertools import permutations



N, M, R = list(map(int, input().split()))

r = list(map(int, input().split()))

G = [[float('inf')] * (N) for _ in range(N)]

for i in range(M):

    a, b, c = list(map(int, input().split()))

    # 経路情報は隣接行列に保持する(無向グラフなので両方向)

    G[a-1][b-1] = c

    G[b-1][a-1] = c



# ワーシャルフロイドで全頂点の最短距離

for k in range(N):

    for i in range(N):

        for j in range(N):

            # 始点 = 終点、は例外的に距離0にしておく

            if i == j:

                G[i][j] = 0

            else:

                G[i][j] = min(G[i][j], G[i][k] + G[k][j])



ans = float('inf')

# 町の順番は順列全部試す(最大8なら大丈夫)

for p in permutations(r):

    sm = 0

    # 最短経路を足し合わせていく

    for i in range(1, len(p)):

        sm += G[p[i-1]-1][p[i]-1]

    ans = min(sm, ans)

print(ans)

# -*- coding: utf-8 -*-



import sys



def input(): return sys.stdin.readline().strip()

def list2d(a, b, c): return [[c] * b for i in range(a)]

def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1): return int(-(-x // y))

def INT(): return int(eval(input()))

def MAP(): return list(map(int, input().split()))

def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes(): print('Yes')

def No(): print('No')

def YES(): print('YES')

def NO(): print('NO')

sys.setrecursionlimit(10 ** 9)

INF = 10 ** 18

MOD = 10 ** 9 + 7



def warshall_floyd(N: int, graph: list) -> list:

    """ ワーシャルフロイド(頂点数, 隣接行列(0-indexed)) """

    from copy import deepcopy



    res = deepcopy(graph)

    for i in range(N):

        # 始点 = 終点、は予め距離0にしておく

        res[i][i] = 0

    # 全頂点の最短距離

    for k in range(N):

        for i in range(N):

            for j in range(N):

                res[i][j] = min(res[i][j], res[i][k] + res[k][j])

    # 負の閉路(いくらでもコストを減らせてしまう場所)がないかチェックする

    for i in range(N):

        if res[i][i] < 0:

            return []

    return res



N, M, R = MAP()

A = [a-1 for a in LIST()]

G = list2d(N, N, INF)

for i in range(M):

    a, b, c = MAP()

    a -= 1; b -= 1

    G[a][b] = c

    G[b][a] = c



# 全体グラフの最短距離(ここから必要な頂点間だけ使う)

wf = warshall_floyd(N, G)



ans = INF

for r in range(R):

    # TSP(巡回セールスマン)

    dp = list2d(1<<R, R, INF)

    dp[1<<r][r] = 0

    for bit in range(1, (1<<R)-1):

        for i in range(R):

            if not (bit >> i & 1):

                continue

            for j in range(R):

                if bit >> j & 1:

                    continue

                a, b = A[i], A[j]

                dp[bit|1<<j][j] = min(dp[bit|1<<j][j], dp[bit][i] + wf[a][b])

    ans = min(ans, min(dp[-1]))

print(ans)

# -*- coding: utf-8 -*-
from itertools import permutations

N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
G = [[float("inf")] * (N) for _ in range(N)]
for i in range(M):
    a, b, c = list(map(int, input().split()))
    # 経路情報は隣接行列に保持する(無向グラフなので両方向)
    G[a - 1][b - 1] = c
    G[b - 1][a - 1] = c
# ワーシャルフロイドで全頂点の最短距離
for k in range(N):
    for i in range(N):
        for j in range(N):
            # 始点 = 終点、は例外的に距離0にしておく
            if i == j:
                G[i][j] = 0
            else:
                G[i][j] = min(G[i][j], G[i][k] + G[k][j])
ans = float("inf")
# 町の順番は順列全部試す(最大8なら大丈夫)
for p in permutations(r):
    sm = 0
    # 最短経路を足し合わせていく
    for i in range(1, len(p)):
        sm += G[p[i - 1] - 1][p[i] - 1]
    ans = min(sm, ans)
print(ans)

# -*- coding: utf-8 -*-
import sys


def input():
    return sys.stdin.readline().strip()


def list2d(a, b, c):
    return [[c] * b for i in range(a)]


def list3d(a, b, c, d):
    return [[[d] * c for j in range(b)] for i in range(a)]


def list4d(a, b, c, d, e):
    return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]


def ceil(x, y=1):
    return int(-(-x // y))


def INT():
    return int(eval(input()))


def MAP():
    return list(map(int, input().split()))


def LIST(N=None):
    return list(MAP()) if N is None else [INT() for i in range(N)]


def Yes():
    print("Yes")


def No():
    print("No")


def YES():
    print("YES")


def NO():
    print("NO")


sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7


def warshall_floyd(N: int, graph: list) -> list:
    """ワーシャルフロイド(頂点数, 隣接行列(0-indexed))"""
    from copy import deepcopy

    res = deepcopy(graph)
    for i in range(N):
        # 始点 = 終点、は予め距離0にしておく
        res[i][i] = 0
    # 全頂点の最短距離
    for k in range(N):
        for i in range(N):
            for j in range(N):
                res[i][j] = min(res[i][j], res[i][k] + res[k][j])
    # 負の閉路(いくらでもコストを減らせてしまう場所)がないかチェックする
    for i in range(N):
        if res[i][i] < 0:
            return []
    return res


N, M, R = MAP()
A = [a - 1 for a in LIST()]
G = list2d(N, N, INF)
for i in range(M):
    a, b, c = MAP()
    a -= 1
    b -= 1
    G[a][b] = c
    G[b][a] = c
# 全体グラフの最短距離(ここから必要な頂点間だけ使う)
wf = warshall_floyd(N, G)
ans = INF
for r in range(R):
    # TSP(巡回セールスマン)
    dp = list2d(1 << R, R, INF)
    dp[1 << r][r] = 0
    for bit in range(1, (1 << R) - 1):
        for i in range(R):
            if not (bit >> i & 1):
                continue
            for j in range(R):
                if bit >> j & 1:
                    continue
                a, b = A[i], A[j]
                dp[bit | 1 << j][j] = min(dp[bit | 1 << j][j], dp[bit][i] + wf[a][b])
    ans = min(ans, min(dp[-1]))
print(ans)

-from itertools import permutations +import sys -N, M, R = list(map(int, input().split())) -r = list(map(int, input().split())) -G = [[float("inf")] * (N) for _ in range(N)] + +def input(): +    return sys.stdin.readline().strip() + + +def list2d(a, b, c): +    return [[c] * b for i in range(a)] + + +def list3d(a, b, c, d): +    return [[[d] * c for j in range(b)] for i in range(a)] + + +def list4d(a, b, c, d, e): +    return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)] + + +def ceil(x, y=1): +    return int(-(-x // y)) + + +def INT(): +    return int(eval(input())) + + +def MAP(): +    return list(map(int, input().split())) + + +def LIST(N=None): +    return list(MAP()) if N is None else [INT() for i in range(N)] + + +def Yes(): +    print("Yes") + + +def No(): +    print("No") + + +def YES(): +    print("YES") + + +def NO(): +    print("NO") + + +sys.setrecursionlimit(10**9) +INF = 10**18 +MOD = 10**9 + 7 + + +def warshall_floyd(N: int, graph: list) -> list: +    """ワーシャルフロイド(頂点数, 隣接行列(0-indexed))""" +    from copy import deepcopy + +    res = deepcopy(graph) +    for i in range(N): +        # 始点 = 終点、は予め距離0にしておく +        res[i][i] = 0 +    # 全頂点の最短距離 +    for k in range(N): +        for i in range(N): +            for j in range(N): +                res[i][j] = min(res[i][j], res[i][k] + res[k][j]) +    # 負の閉路(いくらでもコストを減らせてしまう場所)がないかチェックする +    for i in range(N): +        if res[i][i] < 0: +            return [] +    return res + + +N, M, R = MAP() +A = [a - 1 for a in LIST()] +G = list2d(N, N, INF) -    a, b, c = list(map(int, input().split())) -    # 経路情報は隣接行列に保持する(無向グラフなので両方向) -    G[a - 1][b - 1] = c -    G[b - 1][a - 1] = c -# ワーシャルフロイドで全頂点の最短距離 -for k in range(N): -    for i in range(N): -        for j in range(N): -            # 始点 = 終点、は例外的に距離0にしておく -            if i == j: -                G[i][j] = 0 -            else: -                G[i][j] = min(G[i][j], G[i][k] + G[k][j]) -ans = float("inf") -# 町の順番は順列全部試す(最大8なら大丈夫) -for p in permutations(r): -    sm = 0 -    # 最短経路を足し合わせていく -    for i in range(1, len(p)): -        sm += G[p[i - 1] - 1][p[i] - 1] -    ans = min(sm, ans) +    a, b, c = MAP() +    a -= 1 +    b -= 1 +    G[a][b] = c +    G[b][a] = c +# 全体グラフの最短距離(ここから必要な頂点間だけ使う) +wf = warshall_floyd(N, G) +ans = INF +for r in range(R): +    # TSP(巡回セールスマン) +    dp = list2d(1 << R, R, INF) +    dp[1 << r][r] = 0 +    for bit in range(1, (1 << R) - 1): +        for i in range(R): +            if not (bit >> i & 1): +                continue +            for j in range(R): +                if bit >> j & 1: +                    continue +                a, b = A[i], A[j] +                dp[bit | 1 << j][j] = min(dp[bit | 1 << j][j], dp[bit][i] + wf[a][b]) +    ans = min(ans, min(dp[-1]))