package main

import (
    "bufio"
    "os"
    "strconv"
    //"strings"
    "fmt"
    "container/heap"
    "math"
)

const INF = 100000000000000000

/*********** PriorityQueue ***********/
type PriorityQueue struct {
    arr []interface{}
    comp CompFunc
}

type CompFunc func(p, q interface{}) bool

func NewPriorityQueue() *PriorityQueue {
    return new(PriorityQueue)
}

func (pq PriorityQueue) Len() int {
    return len(pq.arr)
}

func (pq PriorityQueue) Swap(i, j int) {
    pq.arr[i], pq.arr[j] = pq.arr[j], pq.arr[i]
}

func (pq PriorityQueue) Less(i, j int) bool{
    return pq.comp(pq.arr[i], pq.arr[j])
}

func (pq *PriorityQueue) Push(x interface{}) {
    pq.arr = append(pq.arr, x)
}

func (pq *PriorityQueue) Pop() interface{} {
    n := pq.Len()
    item := pq.arr[n - 1]
    pq.arr = pq.arr[:n - 1]
    return item
}

func (pq *PriorityQueue) IsEmpty() bool {
    return pq.Len() == 0
}

/* type for dijkstra */
type State struct {
    time int
    node int
}

/* type for Edge */
type Edge struct {
    to int
    cost int
}

/* type for bitDp */
type BitAndPos struct {
    bit int
    pos int
}

func (bap *BitAndPos) toHash() int{
    return bap.bit + pow(2, 10 + bap.pos)
}

/* math func */
func min(a, b int) int {
    return int(math.Min(float64(a), float64(b)))
}

func pow(a, b int) int {
    return int(math.Pow(float64(a), float64(b)))
}

/* dijkstra */
func dijkstra(start int, n int, edges [][]Edge, comp CompFunc) []int {
    var dist []int
    for i := 0; i < n; i++ {
        dist = append(dist, INF)
    }
    dist[start] = 0
    que := new(PriorityQueue)
    que.comp = comp
    heap.Push(que, State{0, start})
    for !que.IsEmpty() {
        state := heap.Pop(que).(State)
        for _, edge := range edges[state.node] {
            newTime := state.time + edge.cost
            if newTime < dist[edge.to] {
                dist[edge.to] = newTime
                heap.Push(que, State{newTime, edge.to})
            }
        }
    }
    return dist
}

/* bitDp */
func minCost(bap *BitAndPos, dic map[int]int, rDist [][]int, r int) int {
    v, ok := dic[bap.toHash()]
    if ok {
        return v
    }
    if bap.bit == pow(2, r) - 1 {
        return 0
    }

    mask := 1
    ret := INF
    for to := 0; to < r; to++ {
        if bap.bit & mask != 0 {
            mask <<= 1
            continue
        }
        ret = min(ret, rDist[bap.pos][to] + minCost(&BitAndPos{bap.bit | mask, to}, dic, rDist, r))
        mask <<= 1
    }
    dic[bap.toHash()] = ret
    return ret
}


/* input */
var sc = bufio.NewScanner(os.Stdin)

func readInt() int {
    sc.Scan()
    n, _ := strconv.Atoi(sc.Text())
    return n
}

func main() {
    sc.Split(bufio.ScanWords)
    n, m, r := readInt(), readInt(), readInt()

    var rList []int
    for i := 0; i < r; i++ {
        rList = append(rList, readInt() - 1)
    }

    var edges [][]Edge
    for i := 0; i < n; i++ {
        edges = append(edges, make([]Edge, 0))
    }

    for i := 0; i < m; i++ {
        a, b, c := readInt() - 1, readInt() - 1, readInt()
        edges[a] = append(edges[a], Edge{b, c})
        edges[b] = append(edges[b], Edge{a, c})
    }

    comp := func(p, q interface{}) bool {
        return p.(State).time < q.(State).time
    }
    var rDist [][]int
    for i, x := range rList {
        dist := dijkstra(x, n, edges, comp)
        rDist = append(rDist, make([]int, 0))
        for _, y := range rList {
            rDist[i] = append(rDist[i], dist[y])
        }
    }
    dic := make(map[int]int, 0)
    ans := INF
    for i := 0; i < r; i++ {
        ans = min(ans, minCost(&BitAndPos{pow(2, i), i}, dic, rDist, r))
    }
    fmt.Println(ans)
}

Measured memory_bytes: 3200