#![allow(non_snake_case,unused_imports,dead_code)]
use std::cmp::max;
use std::cmp::min;
use std::str::FromStr;
use std::collections::{HashMap,HashSet,VecDeque,BinaryHeap};
use std::cmp::Ordering;

use proconio::input;
use proconio::marker::{Chars,Usize1,Isize1};

fn comp_f64(a: &f64, b: &f64) -> Ordering {
    if a < b {
        return Ordering::Less;
    } else if a > b {
        return Ordering::Greater;
    }
    Ordering::Equal
}

fn main() {
    input!{
        N:usize,
        M:usize,
        L:usize,
        R:[Usize1;L],
        ABC:[(Usize1,Usize1,isize);M]
    }
    let INF = 1e15 as isize;
    let mut G = GraphWarshallFloyd::new(N,INF);
    for &(a,b,c) in &ABC{
        G.set(a,b,c);
        G.set(b,a,c);
    }
    G.run();
    let mut ans = INF;
    for S in Permutations::new(&R){
        ans = min(ans,f(L,&S,&G));
    }
    println!("{}",ans);
}

fn f(N:usize,V:&Vec<usize>,G:&GraphWarshallFloyd)->isize{
    let mut ret = 0;
    for i in 0..N-1{
        ret += G.get(V[i],V[i+1]);
    }
    ret
}

struct Permutations<'a,T:Copy>{
    N:usize,
    V:&'a Vec<T>,
    curr:Option<Vec<usize>>,
}
impl<T:Copy> Permutations<'_,T>{
    fn new(V:&Vec<T>) -> Permutations<T>{
        let N = V.len();
        Permutations{
            N:N,
            V:V,
            curr:None
        }
    }
    fn next_permutation(&mut self){
        if let Some(curr) = &mut self.curr{
            let mut i = self.N-1;
            let mut m = curr[self.N-1];
            for j in (0..self.N-1).rev(){
                if m>curr[j] { break;}
                m = curr[j];
                i = j;
            }
            if i==0{
                self.curr = None;
                return;
            }
            i -= 1;
            let mut done = 0usize;
            for j in 0..i{
                done |= 1<<curr[j];
            }
            for j in curr[i]+1..self.N{
                if done>>j&1 == 1 {continue;}
                curr[i] = j;
                done |= 1<<j;
                break;
            }
            let mut k = i+1;
            for j in 0..self.N{
                if done>>j&1 == 1 {continue;}
                curr[k] = j;
                k += 1;
            }
        } else {
            self.curr = Some((0..self.N).collect::<Vec<_>>());
        }
    }
}
impl<T:Copy> Iterator for Permutations<'_,T>{
    type Item = Vec<T>;
    fn next(&mut self)->Option<Vec<T>>{
        self.next_permutation();
        if let Some(curr) = &self.curr{
            let mut ret = Vec::new();
            for &i in curr {
                ret.push(self.V[i]);
            }
            Some(ret)
        } else {
            None
        }
    }
}

struct GraphWarshallFloyd{
    N:usize,
    Dist:Vec<Vec<isize>>,
    INF:isize
}

impl GraphWarshallFloyd {
    fn new(N:usize,INF:isize) -> GraphWarshallFloyd{
        let mut ret = GraphWarshallFloyd{N:N,Dist:Vec::new(),INF:INF};
        ret.Dist = vec![vec![INF;N];N];
        for i in 0..N{
            ret.Dist[i][i] = 0;
        }
        ret
    }
    fn set(&mut self,from:usize,to:usize,dist:isize){
        self.Dist[from][to] = dist;
    }
    fn get(&self,from:usize,to:usize)->isize{
        self.Dist[from][to]
    }
    fn run(&mut self){
        let N = self.N;
        for k in 0..N{
            for i in 0..N{
                for j in 0..N{
                    self.Dist[i][j] = min(self.Dist[i][j],self.Dist[i][k]+self.Dist[k][j]);
                }
            }
        }
    }
}

Measured memory_bytes: 2984