use proconio::input;
#[allow(unused_imports)]
use proconio::marker::{Bytes, Chars};
#[allow(unused_imports)]
use std::cmp::{min, max};
use std::collections::VecDeque;

  
/// Permute a slice into its next or previous permutation (in lexical order).
///
/// ```
/// use permutohedron::LexicalPermutation;
///
/// let mut data = [1, 2, 3];
/// let mut permutations = Vec::new();
///
/// loop {
///     permutations.push(data.to_vec());
///     if !data.next_permutation() {
///         break;
///     }
/// }
///
/// assert_eq!(permutations, &[&[1, 2, 3], &[1, 3, 2],
///                            &[2, 1, 3], &[2, 3, 1],
///                            &[3, 1, 2], &[3, 2, 1]]);
///
/// // `data` has been mutated in-place:
/// assert_eq!(data, [3, 2, 1]);
/// ```
pub trait LexicalPermutation {
    /// Return `true` if the slice was permuted, `false` if it is already
    /// at the last ordered permutation.
    fn next_permutation(&mut self) -> bool;
    /// Return `true` if the slice was permuted, `false` if it is already
    /// at the first ordered permutation.
    fn prev_permutation(&mut self) -> bool;
}

impl<T> LexicalPermutation for [T] where T: Ord {
    /// Original author in Rust: Thomas Backman <serenity@exscape.org>
    fn next_permutation(&mut self) -> bool {
        // These cases only have 1 permutation each, so we can't do anything.
        if self.len() < 2 { return false; }

        // Step 1: Identify the longest, rightmost weakly decreasing part of the vector
        let mut i = self.len() - 1;
        while i > 0 && self[i-1] >= self[i] {
            i -= 1;
        }

        // If that is the entire vector, this is the last-ordered permutation.
        if i == 0 {
            return false;
        }

        // Step 2: Find the rightmost element larger than the pivot (i-1)
        let mut j = self.len() - 1;
        while j >= i && self[j] <= self[i-1]  {
            j -= 1;
        }

        // Step 3: Swap that element with the pivot
        self.swap(j, i-1);

        // Step 4: Reverse the (previously) weakly decreasing part
        self[i..].reverse();

        true
    }

    fn prev_permutation(&mut self) -> bool {
        // These cases only have 1 permutation each, so we can't do anything.
        if self.len() < 2 { return false; }

        // Step 1: Identify the longest, rightmost weakly increasing part of the vector
        let mut i = self.len() - 1;
        while i > 0 && self[i-1] <= self[i] {
            i -= 1;
        }

        // If that is the entire vector, this is the first-ordered permutation.
        if i == 0 {
            return false;
        }

        // Step 2: Reverse the weakly increasing part
        self[i..].reverse();

        // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
        let mut j = self.len() - 1;
        while j >= i && self[j-1] < self[i-1]  {
            j -= 1;
        }

        // Step 4: Swap that element with the pivot
        self.swap(i-1, j);

        true
    }

}

fn main() {
	input! {
		n: usize,
		m: usize,
		rnum: usize,
		mut r: [usize; rnum],
		abc: [(usize, usize, usize); m],
	}

	let inf = 999999999999999999usize;

	let mut v: Vec<Vec<(usize, usize)>> = vec![vec![]; n];

	for i in 0..m {
		v[abc[i].0-1].push((abc[i].1-1, abc[i].2));
		v[abc[i].1-1].push((abc[i].0-1, abc[i].2));
	}

	// すべての町間の距離を求める
	let mut d: Vec<Vec<usize>> = vec![vec![inf; n]; n];
	// 起点iから幅優先で
	for i in 0..n {
		let mut q = VecDeque::new();
		q.push_back((i, 0));
		while q.len() > 0 {
			let tmp = q.pop_front().unwrap();
			if d[i][tmp.0] <= tmp.1 {
				continue;
			}
			d[i][tmp.0] = tmp.1;
//			d[tmp.0][i] = tmp.1;
			for j in 0..v[tmp.0].len() {
				q.push_back((v[tmp.0][j].0, tmp.1+v[tmp.0][j].1));
			}
		}
	}
//	println!("{:?}", d);

	let mut dmin = inf;
	for i1 in 0..rnum {
		let mut r1 = r.clone();
		r1.remove(i1);
		if rnum == 2 {
			let x = [r[i1], r1[0]];
			let mut dsum = 0usize;
			let mut p = x[0]-1;
			for j in 1..rnum {
				dsum += d[p][x[j]-1];
				p = x[j]-1;
			}
			dmin = min(dmin, dsum);
			continue;
		}
		for i2 in 0..rnum-1 {
			let mut r2 = r1.clone();
			r2.remove(i2);
			if rnum == 3 {
				let x = [r[i1], r1[i2], r2[0]];
				let mut dsum = 0usize;
				let mut p = x[0]-1;
				for j in 1..rnum {
					dsum += d[p][x[j]-1];
					p = x[j]-1;
				}
				dmin = min(dmin, dsum);
				continue;
			}
			for i3 in 0..rnum-2 {
				let mut r3 = r2.clone();
				r3.remove(i3);
				if rnum == 4 {
					let x = [r[i1], r1[i2], r2[i3], r3[0]];
					let mut dsum = 0usize;
					let mut p = x[0]-1;
					for j in 1..rnum {
						dsum += d[p][x[j]-1];
						p = x[j]-1;
					}
					dmin = min(dmin, dsum);
					continue;
				}
				for i4 in 0..rnum-3 {
					let mut r4 = r3.clone();
					r4.remove(i4);
					if rnum == 5 {
						let x = [r[i1], r1[i2], r2[i3], r3[i4], r4[0]];
						let mut dsum = 0usize;
						let mut p = x[0]-1;
						for j in 1..rnum {
							dsum += d[p][x[j]-1];
							p = x[j]-1;
						}
						dmin = min(dmin, dsum);
						continue;
					}
					for i5 in 0..rnum-4 {
						let mut r5 = r4.clone();
						r5.remove(i5);
						if rnum == 6 {
							let x = [r[i1], r1[i2], r2[i3], r3[i4], r4[i5], r5[0]];
							let mut dsum = 0usize;
							let mut p = x[0]-1;
							for j in 1..rnum {
								dsum += d[p][x[j]-1];
								p = x[j]-1;
							}
							dmin = min(dmin, dsum);
							continue;
						}
						for i6 in 0..rnum-5 {
							let mut r6 = r5.clone();
							r6.remove(i6);
							if rnum == 7 {
								let x = [r[i1], r1[i2], r2[i3], r3[i4], r4[i5], r5[i6], r6[0]];
								let mut dsum = 0usize;
								let mut p = x[0]-1;
								for j in 1..rnum {
									dsum += d[p][x[j]-1];
									p = x[j]-1;
								}
								dmin = min(dmin, dsum);
								continue;
							}
							for i7 in 0..rnum-6 {
								let mut r7 = r6.clone();
								r7.remove(i7);
								let x = [r[i1], r1[i2], r2[i3], r3[i4], r4[i5], r5[i6], r6[i7], r7[0]];
								let mut dsum = 0usize;
								let mut p = x[0]-1;
								for j in 1..rnum {
									dsum += d[p][x[j]-1];
									p = x[j]-1;
								}
								dmin = min(dmin, dsum);		
							}
						}
					}
				}
			}
		}
	}
	println!("{}", dmin);
}


Measured memory_bytes: 10156