use std::io::*;
use std::str::*;
use std::collections::BinaryHeap;
use std::cmp::Ordering;
fn generate(n : usize, a : &mut Vec<usize> ,b:&mut Vec<Vec<usize>>) {
    if n == 1 {
        b.push(a.clone());
        //println!("{:?}", a,b);
    }
    else {
        for i in  0 .. n - 1 {
            generate(n - 1, a,b);

            if n % 2 == 0 {
                a.swap(i, n - 1);
            }
            else {
                a.swap(0, n - 1);
            }
        }
        generate(n - 1, a,b);
    }
}
fn main(){
    let n = read::<usize>();
    let m = read::<usize>();
    let R = read::<usize>();
    let mut r =  vec![0;R];
    for i in 0..R{
        r[i] = read::<usize>();
    }
    let mut dij = Dijkstra::new(n+10);
    for i in 0 .. m{
        let a = read::<usize>();
        let b = read::<usize>();
        let c = read::<usize>();
        dij.add_biedge(a,b,c);
    }
    let mut dist = vec![vec![0;R];R];
    for i in 0..R{
        dij.exec(r[i]);
        for j in 0..R{
            dist[i][j] = dij.get(r[j]);
        }
    }
    let mut per = Vec::<Vec<usize>>::new();
    let mut a = vec![0;R];
    for i in 0..R{
        a[i] = i;
    }
    generate(R,&mut a,&mut per);
    let mut ans = 100000000000;
    for i in 0..per.len(){
        let mut sum = 0;
        for j in 0 ..(R-1) {
            sum += dist[per[i][j]][per[i][j+1]] ;
        }
        if ans > sum {
            ans = sum;
        }
    }
    println!("{}",ans);
}
#[derive(Copy, Clone, Eq, PartialEq)]
struct State{
    cost : usize,
    pos :usize
}
impl Ord for State{
    fn cmp(&self,other:&State)->Ordering{
        other.cost.cmp(&self.cost)
    }
}
impl PartialOrd for State{
    fn partial_cmp(&self,other:&State)->Option<Ordering>{
        Some(self.cmp(other))
    }
}

#[derive(Copy, Clone)]
struct Edge{
    to:usize,
    cost:usize
}
struct Dijkstra{
    e:Vec<Vec<Edge>>,
    n:usize,
    dist:Vec<usize>
}
impl Dijkstra{
    pub fn new(n:usize)->Dijkstra{
        Dijkstra{e:vec![Vec::<Edge>::new();n],n:n,dist:vec![0;n]}
    }
    pub fn init(&mut self) {
        let INF = 100000000000000;
        self.dist = vec![INF;self.n];
    }
    pub fn add_biedge(&mut self,u:usize,v:usize,cost:usize){
        self.e[u].push(Edge{to:v,cost:cost});
        self.e[v].push(Edge{to:u,cost:cost});
    }
    pub fn exec(&mut self,s:usize){
        self.init();
        self.dist[s] = 0;
        let mut heap = BinaryHeap::new();
        heap.push(State{cost:0,pos:s});
        while let Some(State{cost,pos}) = heap.pop(){
            if cost > self.dist[pos] {continue;}
            for edge in &self.e[pos] {
                let next = State { cost:cost +edge.cost ,pos : edge.to};
                if next.cost < self.dist[next.pos]{
                    heap.push(next);
                    self.dist[next.pos] = next.cost;
                }
            }
        }
    }
    pub fn get(&self,s:usize)->usize{
        self.dist[s]
    }
}

#[allow(dead_code)]
fn read_str() -> Vec<char>{
    let s :String = read();
    s.chars().collect::<Vec<char>>()
}
#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let s = stdin.bytes().map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().unwrap_or_else(|_| panic!("Faild to parse {}", s))
}


Measured memory_bytes: 8444