package main

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

const NEG int64 = -1 << 60

type Edge struct {
	to int
	w  int64
}

type Top struct {
	m1Val            int64
	m1Cnt            int
	m1Id1, m1Meet1   int
	m1Id2, m1Meet2   int
	m2Val            int64
	m2Cnt            int
	m2Id1, m2Meet1   int
}

func (t *Top) add(val int64, id, meet int) {
	if val == NEG {
		return
	}
	if val > t.m1Val {
		t.m2Val = t.m1Val
		t.m2Cnt = t.m1Cnt
		t.m2Id1 = t.m1Id1
		t.m2Meet1 = t.m1Meet1
		t.m1Val = val
		t.m1Cnt = 1
		t.m1Id1 = id
		t.m1Meet1 = meet
		t.m1Id2 = 0
		t.m1Meet2 = 0
	} else if val == t.m1Val {
		t.m1Cnt++
		if t.m1Cnt == 2 {
			t.m1Id2 = id
			t.m1Meet2 = meet
		}
	} else if val > t.m2Val {
		t.m2Val = val
		t.m2Cnt = 1
		t.m2Id1 = id
		t.m2Meet1 = meet
	} else if val == t.m2Val {
		t.m2Cnt++
	}
}

func (t *Top) bestExcluding(cand int64, id int) (int64, bool, int) {
	if cand == NEG || cand < t.m1Val {
		if t.m1Val == NEG {
			return NEG, false, 0
		}
		if t.m1Cnt == 1 {
			return t.m1Val, false, t.m1Meet1
		}
		return t.m1Val, true, 0
	}
	if t.m1Cnt > 1 {
		if t.m1Cnt > 2 {
			return t.m1Val, true, 0
		}
		if t.m1Id1 == id {
			return t.m1Val, false, t.m1Meet2
		}
		return t.m1Val, false, t.m1Meet1
	}
	if t.m2Val == NEG {
		return NEG, false, 0
	}
	if t.m2Cnt == 1 {
		return t.m2Val, false, t.m2Meet1
	}
	return t.m2Val, true, 0
}

var (
	parent []int
	depth  []int
	up     [][]int
	LOG    int
)

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

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

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

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

	g := make([][]Edge, n+1)
	for i := 0; i < n-1; i++ {
		a := nextInt()
		b := nextInt()
		c := nextInt()
		w := int64(c)
		g[a] = append(g[a], Edge{b, w})
		g[b] = append(g[b], Edge{a, w})
	}

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

	LOG = 1
	for (1 << LOG) <= n {
		LOG++
	}
	up = make([][]int, LOG)
	up[0] = make([]int, n+1)
	copy(up[0], parent)
	for k := 1; k < LOG; k++ {
		up[k] = make([]int, n+1)
		prev := up[k-1]
		cur := up[k]
		for i := 1; i <= n; i++ {
			if prev[i] != 0 {
				cur[i] = prev[prev[i]]
			}
		}
	}

	subDist := make([]int64, n+1)
	outDist := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		subDist[i] = NEG
		outDist[i] = NEG
	}
	subMeet := make([]int, n+1)
	outMeet := make([]int, n+1)
	cNode := make([]int, n+1)

	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		bestVal := NEG
		bestCnt := 0
		bestMeet := 0
		if monastery[u] {
			bestVal = 0
			bestCnt = 1
			bestMeet = u
		}
		for _, e := range g[u] {
			v := e.to
			if parent[v] != u {
				continue
			}
			if subDist[v] == NEG {
				continue
			}
			cand := e.w + subDist[v]
			if cand > bestVal {
				bestVal = cand
				bestCnt = 1
				bestMeet = subMeet[v]
			} else if cand == bestVal {
				bestCnt++
			}
		}
		subDist[u] = bestVal
		if bestVal == NEG {
			subMeet[u] = 0
		} else if bestCnt == 1 {
			subMeet[u] = bestMeet
		} else {
			subMeet[u] = u
		}
	}

	for _, u := range order {
		meta := Top{m1Val: NEG, m2Val: NEG}

		nbVal := NEG
		nbCnt := 0
		nbMeet := 0

		if outDist[u] != NEG {
			meta.add(outDist[u], 0, outMeet[u])
			if outDist[u] > nbVal {
				nbVal = outDist[u]
				nbCnt = 1
				nbMeet = outMeet[u]
			} else if outDist[u] == nbVal {
				nbCnt++
			}
		}

		if monastery[u] {
			meta.add(0, -1, u)
		}

		for _, e := range g[u] {
			v := e.to
			if parent[v] != u {
				continue
			}
			if subDist[v] != NEG {
				cand := e.w + subDist[v]
				meta.add(cand, v, subMeet[v])
				if cand > nbVal {
					nbVal = cand
					nbCnt = 1
					nbMeet = subMeet[v]
				} else if cand == nbVal {
					nbCnt++
				}
			}
		}

		if nbCnt == 1 {
			cNode[u] = nbMeet
		} else {
			cNode[u] = u
		}

		for _, e := range g[u] {
			v := e.to
			if parent[v] != u {
				continue
			}
			cand := NEG
			if subDist[v] != NEG {
				cand = e.w + subDist[v]
			}
			val, multi, meet := meta.bestExcluding(cand, v)
			if val == NEG {
				outDist[v] = NEG
				outMeet[v] = 0
			} else {
				outDist[v] = e.w + val
				if multi {
					outMeet[v] = u
				} else {
					outMeet[v] = meet
				}
			}
		}
	}

	diff := make([]int64, n+1)
	for _, u := range monList {
		v := cNode[u]
		l := lca(u, v)
		diff[u]++
		diff[v]++
		diff[l]--
		if parent[l] != 0 {
			diff[parent[l]]--
		}
	}

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

	var maxCnt int64 = -1
	var ways int64 = 0
	for i := 1; i <= n; i++ {
		if monastery[i] {
			continue
		}
		if diff[i] > maxCnt {
			maxCnt = diff[i]
			ways = 1
		} else if diff[i] == maxCnt {
			ways++
		}
	}

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