package main

import (
	"bufio"
	"os"
	"sort"
	"strconv"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024*10)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		b := scanner.Bytes()
		res := 0
		for _, v := range b {
			res = res*10 + int(v-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	b := scanner.Bytes()
	t := 0
	for _, v := range b {
		t = t*10 + int(v-'0')
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for tc := 0; tc < t; tc++ {
		n := readInt()
		m := readInt()
		p := readInt()

		S := make([]int, p)
		for i := 0; i < p; i++ {
			S[i] = readInt()
		}

		type Edge struct{ u, v, w int }
		edges := make([]Edge, m)
		for i := 0; i < m; i++ {
			edges[i].u = readInt()
			edges[i].v = readInt()
			edges[i].w = readInt()
		}

		sort.Slice(edges, func(i, j int) bool {
			return edges[i].w < edges[j].w
		})

		parent := make([]int, 2*n)
		for i := 1; i < 2*n; i++ {
			parent[i] = i
		}

		find := func(i int) int {
			root := i
			for root != parent[root] {
				root = parent[root]
			}
			curr := i
			for curr != root {
				nxt := parent[curr]
				parent[curr] = root
				curr = nxt
			}
			return root
		}

		krt_parent := make([]int, 2*n)
		left := make([]int, 2*n)
		right := make([]int, 2*n)
		W := make([]int64, 2*n)

		node_cnt := n
		for _, e := range edges {
			r1 := find(e.u)
			r2 := find(e.v)
			if r1 != r2 {
				node_cnt++
				W[node_cnt] = int64(e.w)
				krt_parent[r1] = node_cnt
				krt_parent[r2] = node_cnt
				left[node_cnt] = r1
				right[node_cnt] = r2
				parent[r1] = node_cnt
				parent[r2] = node_cnt
			}
		}

		c := make([]int64, 2*n)
		for _, s := range S {
			c[s] = 1
		}

		for i := 1; i < node_cnt; i++ {
			p_node := krt_parent[i]
			c[p_node] += c[i]
		}

		weight := make([]int64, 2*n)
		for i := 1; i < node_cnt; i++ {
			p_node := krt_parent[i]
			weight[i] = (W[p_node] - W[i]) * c[i]
		}

		dp := make([]int64, 2*n)
		heavy := make([]int, 2*n)

		for i := 1; i <= node_cnt; i++ {
			if left[i] != 0 {
				dp[i] = -1
				
				v := left[i]
				val := dp[v] + weight[v]
				if val > dp[i] {
					dp[i] = val
					heavy[i] = v
				}
				
				v = right[i]
				val = dp[v] + weight[v]
				if val > dp[i] {
					dp[i] = val
					heavy[i] = v
				}
			}
		}

		is_light := make([]bool, 2*n)
		is_light[node_cnt] = true

		for i := node_cnt; i >= 1; i-- {
			if left[i] != 0 {
				h := heavy[i]
				
				v := left[i]
				if v == h {
					is_light[v] = false
				} else {
					is_light[v] = true
				}
				
				v = right[i]
				if v == h {
					is_light[v] = false
				} else {
					is_light[v] = true
				}
			}
		}

		paths := make([]int64, 0, n)
		for i := 1; i <= node_cnt; i++ {
			if is_light[i] {
				var pw int64
				if i == node_cnt {
					pw = dp[i]
				} else {
					pw = dp[i] + weight[i]
				}
				paths = append(paths, pw)
			}
		}

		sort.Slice(paths, func(i, j int) bool {
			return paths[i] > paths[j]
		})

		ans := int64(p) * W[node_cnt]
		for k := 1; k <= n; k++ {
			if k-1 < len(paths) {
				ans -= paths[k-1]
			}
			out.WriteString(strconv.FormatInt(ans, 10))
			if k == n {
				out.WriteByte('\n')
			} else {
				out.WriteByte(' ')
			}
		}
	}
}