```go
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

const (
	NEG  int64 = -1 << 60
	SELF int   = -1
	NONE int   = -2
)

type Meta struct {
	max1, max2   int64
	cnt1, cnt2   int
	id1a, id1b   int
	id2          int
}

func addOption(md *Meta, val int64, id int) {
	if val > md.max1 {
		md.max2, md.cnt2 = md.max1, md.cnt1
		if md.cnt1 == 1 {
			md.id2 = md.id1a
		} else {
			md.id2 = NONE
		}
		md.max1, md.cnt1 = val, 1
		md.id1a, md.id1b = id, NONE
	} else if val == md.max1 {
		if md.cnt1 == 1 {
			md.id1b = id
		}
		md.cnt1++
	} else if val > md.max2 {
		md.max2, md.cnt2, md.id2 = val, 1, id
	} else if val == md.max2 {
		md.cnt2++
	}
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && data[idx] <= ' ' {
			idx++
		}
		sign := 1
		if idx < len(data) && data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] > ' ' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return sign * val
	}

	n := nextInt()
	m := nextInt()

	marked := make([]bool, n+1)
	monasteries := make([]int, m)
	for i := 0; i < m; i++ {
		x := nextInt()
		monasteries[i] = x
		marked[x] = true
	}

	adj := make([][]int, n+1)
	from := make([]int, 0, 2*(n-1))
	to := make([]int, 0, 2*(n-1))
	wt := make([]int64, 0, 2*(n-1))

	addEdge := func(a, b int, w int64) {
		id := len(to)
		from = append(from, a, b)
		to = append(to, b, a)
		wt = append(wt, w, w)
		adj[a] = append(adj[a], id)
		adj[b] = append(adj[b], id+1)
	}

	for i := 0; i < n-1; i++ {
		a := nextInt()
		b := nextInt()
		c := nextInt()
		addEdge(a, b, int64(c))
	}

	parent := make([]int, n+1)
	depth := make([]int, n+1)
	order := make([]int, 0, n)
	stack := []int{1}
	parent[1] = 0

	for len(stack) > 0 {
		v := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, v)
		for _, e := range adj[v] {
			u := to[e]
			if u == parent[v] {
				continue
			}
			parent[u] = v
			depth[u] = depth[v] + 1
			stack = append(stack, u)
		}
	}

	LOG := 1
	for (1 << LOG) <= n {
		LOG++
	}
	upAnc := make([][]int, LOG)
	upAnc[0] = make([]int, n+1)
	copy(upAnc[0], parent)
	for k := 1; k < LOG; k++ {
		upAnc[k] = make([]int, n+1)
		for v := 1; v <= n; v++ {
			upAnc[k][v] = upAnc[k-1][upAnc[k-1][v]]
		}
	}

	lca := func(a, b int) int {
		if depth[a] < depth[b] {
			a, b = b, a
		}
		d := depth[a] - depth[b]
		k := 0
		for d > 0 {
			if d&1 == 1 {
				a = upAnc[k][a]
			}
			d >>= 1
			k++
		}
		if a == b {
			return a
		}
		for k = LOG - 1; k >= 0; k-- {
			if upAnc[k][a] != upAnc[k][b] {
				a = upAnc[k][a]
				b = upAnc[k][b]
			}
		}
		return parent[a]
	}

	sub := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		sub[i] = NEG
	}
	for i := len(order) - 1; i >= 0; i-- {
		v := order[i]
		best := NEG
		if marked[v] {
			best = 0
		}
		for _, e := range adj[v] {
			u := to[e]
			if parent[u] == v && sub[u] != NEG {
				val := wt[e] + sub[u]
				if val > best {
					best = val
				}
			}
		}
		sub[v] = best
	}

	upDist := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		upDist[i] = NEG
	}
	for _, v := range order {
		childTop1, childTop2 := NEG, NEG
		childCnt1 := 0
		for _, e := range adj[v] {
			u := to[e]
			if parent[u] == v && sub[u] != NEG {
				val := wt[e] + sub[u]
				if val > childTop1 {
					childTop2 = childTop1
					childTop1 = val
					childCnt1 = 1
				} else if val == childTop1 {
					childCnt1++
				} else if val > childTop2 {
					childTop2 = val
				}
			}
		}

		base := NEG
		if marked[v] {
			base = 0
		}
		if upDist[v] > base {
			base = upDist[v]
		}

		for _, e := range adj[v] {
			u := to[e]
			if parent[u] != v {
				continue
			}
			other := childTop1
			if sub[u] != NEG {
				val := wt[e] + sub[u]
				if val == childTop1 && childCnt1 == 1 {
					other = childTop2
				}
			}
			best := base
			if other > best {
				best = other
			}
			if best != NEG {
				upDist[u] = wt[e] + best
			}
		}
	}

	dirVal := make([]int64, len(to))
	for i := range dirVal {
		dirVal[i] = NEG
	}
	for v := 1; v <= n; v++ {
		for _, e := range adj[v] {
			u := to[e]
			if parent[u] == v {
				if sub[u] != NEG {
					dirVal[e] = wt[e] + sub[u]
				}
			} else if parent[v] == u {
				dirVal[e] = upDist[v]
			}
		}
	}

	meta := make([]Meta, n+1)
	for v := 1; v <= n; v++ {
		meta[v] = Meta{max1: NEG, max2: NEG, id1a: NONE, id1b: NONE, id2: NONE}
		if marked[v] {
			addOption(&meta[v], 0, SELF)
		}
		for _, e := range adj[v] {
			if dirVal[e] != NEG {
				addOption(&meta[v], dirVal[e], e)
			}
		}
	}

	succ := make([]int, len(to))
	terminal := make([]int, len(to))
	for i := range succ {
		succ[i] = -1
	}

	for e := 0; e < len(to); e++ {
		cur := to[e]
		ex := e ^ 1
		md := meta[cur]
		valEx := dirVal[ex]

		topCnt := 0
		unique := NONE

		if valEx != md.max1 {
			topCnt = md.cnt1
			if topCnt == 1 {
				unique = md.id1a
			}
		} else {
			if md.cnt1 >= 2 {
				topCnt = md.cnt1 - 1
				if topCnt == 1 {
					if md.id1a == ex {
						unique = md.id1b
					} else {
						unique = md.id1a
					}
				}
			} else {
				topCnt = md.cnt2
				if topCnt == 1 {
					unique = md.id2
				}
			}
		}

		if topCnt == 1 && unique >= 0 {
			succ[e] = unique
		} else {
			if topCnt >= 2 && !marked[cur] {
				terminal[e] = cur
			} else {
				terminal[e] = from[e]
			}
		}
	}

	endMemo := make([]int, len(to))
	resolve := func(start int) int {
		if endMemo[start] != 0 {
			return endMemo[start]
		}
		path := make([]int, 0, 8)
		e := start
		end := 0
		for {
			if endMemo[e] != 0 {
				end = endMemo[e]
				break
			}
			path = append(path, e)
			if succ[e] == -1 {
				end = terminal[e]
				break
			}
			e = succ[e]
		}
		for i := len(path) - 1; i >= 0; i-- {
			endMemo[path[i]] = end
		}
		return end
	}

	diff := make([]int, n+1)
	addPath := func(a, b int) {
		l := lca(a, b)
		diff[a]++
		diff[b]++
		diff[l]--
		if parent[l] != 0 {
			diff[parent[l]]--
		}
	}

	for _, u := range monasteries {
		md := meta[u]
		if md.cnt1 == 1 && md.id1a >= 0 {
			t := resolve(md.id1a)
			if t != u {
				addPath(u, t)
			}
		}
	}

	for i := len(order) - 1; i > 0; i-- {
		v := order[i]
		diff[parent[v]] += diff[v]
	}

	best := -1
	ways := 0
	for v := 1; v <= n; v++ {
		if marked[v] {
			continue
		}
		if diff[v] > best {
			best = diff[v]
			ways = 1
		} else if diff[v] == best {
			ways++
		}
	}

	out := bufio.NewWriter(os.Stdout)
	fmt.Fprintf(out, "%d %d", best, ways)
	out.Flush()
}
```