#!/bin/python3

import math
import os
import random
import re
import sys

# Let's use an adapted form of Kruskal.
# 1. Construct a set for each city.
# 2. Iterate through edges in descending order of "cost to destroy".
# 3. If the edge connects two machines, we must destroy it so add to total time.
#    If the edge does not connect two machines, we do not need to destroy it.
# 4. After iterating through all edges, return total time

# From https://en.wikipedia.org/wiki/Kruskal%27s_algorithm#Pseudocode
# KRUSKAL(G):
# A = ∅
# foreach v ∈ G.V:
#    MAKE-SET(v)
# foreach (u, v) in G.E ordered by weight(u, v), increasing:
#    if FIND-SET(u) ≠ FIND-SET(v):
#       A = A ∪ {(u, v)}
#       UNION(u, v)
# return A


class Matrix:

    MACHINE = "MACHINE"

    def __init__(self, roads, num_cities, machines):
        self.roads = roads
        self.num_cities = num_cities
        self.machines = machines

        self.sets = [[city] for city in range(num_cities)]
        self.set_member_lookup = {city: city for city in range(num_cities)}

        self.mark_cities_with_machines(machines)

    def mark_cities_with_machines(self, machines):
        for machine in machines:
            city_with_machine = self.get_set_for_city(machine)
            city_with_machine.append(self.MACHINE)

    def get_set_for_city(self, city):
        return self.sets[self.find_set(city)]

    def find_set(self, city):
        return self.set_member_lookup[city]

    def build_road(self, city_a, city_b):
        set_a = self.get_set_for_city(city_a)
        set_b = self.get_set_for_city(city_b)

        if set_a is not None and set_b is not None:
            set_a.extend(set_b)
            set_a_lookup = self.find_set(city_a)
            for city in set_b:
                self.set_member_lookup[city] = set_a_lookup
            set_b = None

    def min_time(self):
        """
        Return an integer representing the minimum time required to disrupt the
        connections among all machines.
        """
        total_time = 0
        descending_roads = list(
            reversed(
                sorted(
                    self.roads,
                    key=lambda tuple: tuple[2])))
        for road in descending_roads:
            city_a, city_b, time_to_destroy = road
            set_a = self.get_set_for_city(city_a)
            set_b = self.get_set_for_city(city_b)
            if self.MACHINE in set_a and self.MACHINE in set_b:
                total_time += time_to_destroy
            else:
                self.build_road(city_a, city_b)
        return total_time


if __name__ == '__main__':
    num_cities, num_machines = map(int, input().split())

    roads = []
    for _ in range(num_cities - 1):
        roads.append(tuple(map(int, input().rstrip().split())))

    machines = []  # these are cities machines are in
    for _ in range(num_machines):
        machines.append(int(input()))

    matrix = Matrix(roads, num_cities, machines)
    print(matrix.min_time())