package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Edge struct {
	u, v, w int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var n, m, p int
		fmt.Fscan(reader, &n, &m, &p)

		inP := make([]bool, n+1)
		for i := 0; i < p; i++ {
			var s int
			fmt.Fscan(reader, &s)
			inP[s] = true
		}

		edges := make([]Edge, m)
		for i := 0; i < m; i++ {
			fmt.Fscan(reader, &edges[i].u, &edges[i].v, &edges[i].w)
		}

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

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

		var find func(int) int
		find = func(i int) int {
			if dsu[i] == i {
				return i
			}
			dsu[i] = find(dsu[i])
			return dsu[i]
		}

		val := make([]int64, 2*n+1)
		adj := make([][]int, 2*n+1)

		numNodes := n
		for _, e := range edges {
			ru := find(e.u)
			rv := find(e.v)
			if ru != rv {
				numNodes++
				val[numNodes] = int64(e.w)
				adj[numNodes] = append(adj[numNodes], ru, rv)
				dsu[ru] = numNodes
				dsu[rv] = numNodes
			}
		}

		root := numNodes

		C := make([]int, 2*n+1)
		W := make([]int64, 2*n+1)

		var dfs func(int, int)
		dfs = func(u, parent int) {
			if u <= n {
				if inP[u] {
					C[u] = 1
				}
			}
			for _, v := range adj[u] {
				dfs(v, u)
				C[u] += C[v]
			}
			if u != root {
				W[u] = int64(C[u]) * (val[parent] - val[u])
			}
		}

		dfs(root, 0)

		var paths []int64
		var getMaxDown func(int) int64
		getMaxDown = func(u int) int64 {
			if len(adj[u]) == 0 {
				return W[u]
			}
			
			var maxCVal int64 = -1
			var bestIdx int = -1
			
			cvs := make([]int64, len(adj[u]))
			for i, v := range adj[u] {
				cv := getMaxDown(v)
				cvs[i] = cv
				if cv > maxCVal {
					maxCVal = cv
					bestIdx = i
				}
			}
			
			for i, cv := range cvs {
				if i != bestIdx {
					paths = append(paths, cv)
				}
			}
			
			return W[u] + maxCVal
		}

		rootVal := getMaxDown(root)
		paths = append(paths, rootVal)

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

		initialCost := int64(p) * val[root]

		var currentSave int64 = 0
		for k := 1; k <= n; k++ {
			if k-1 < len(paths) {
				currentSave += paths[k-1]
			}
			fmt.Fprintf(writer, "%d", initialCost-currentSave)
			if k < n {
				fmt.Fprint(writer, " ")
			}
		}
		fmt.Fprintln(writer)
	}
}