// Arup Guha
// 6/4/2018
// Solution to 2013 KTH Problem D: Chicken Joggers

import java.util.*;
import java.io.*;

public class joggers {

	public static int n;
	public static int dist;
	public static node[] list;
	public static edge[] eList;

	public static void main(String[] args) throws Exception {

		// Get basic input.
		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer tok = new StringTokenizer(stdin.readLine());
		n = Integer.parseInt(tok.nextToken());
		dist = Integer.parseInt(tok.nextToken());

		// Form nodes.
		list = new node[n];
		for (int i=0; i<n; i++) list[i] = new node(i);

		// Read in edges add to nodes.
		eList = new edge[n-1];
		for (int i=0; i<n-1; i++) {
			tok = new StringTokenizer(stdin.readLine());
			int v1 = Integer.parseInt(tok.nextToken())-1;
			int v2 = Integer.parseInt(tok.nextToken())-1;
			int w = Integer.parseInt(tok.nextToken());
			eList[i] = new edge(v1, v2, w);
			list[v1].kids.add(eList[i]);
			list[v2].kids.add(eList[i]);
		}

		// Update the free light information.
		int numL = Integer.parseInt(stdin.readLine().trim());
		tok = new StringTokenizer(stdin.readLine());
		for (int i=0; i<numL; i++) {
			int v = Integer.parseInt(tok.nextToken())-1;
			list[v].freeLight = true;
		}

		// Start the DFS to mark parents, distances.
		dfs(0,-1, 0);

		// Now, solve it!
		solve(0);

		// We want the lower of our two answers.
		System.out.println(Math.min(list[0].zeroAns, list[0].oneAns));
	}

	// Run a DFS on me from parent mypar. The distance to me from root is newd.
	public static void dfs(int me, int mypar, int newd) {

		// Set these.
		list[me].par = mypar;
		list[me].dRoot = newd;

		// Go to actual kids.
		for (int i=0; i<list[me].kids.size(); i++) {
			edge e = (edge)(list[me].kids.get(i));
			if (e.v1 == list[me].par || e.v2 == list[me].par) continue;

			// This is the next vertex.
			int next = e.v1 == me ? e.v2 : e.v1;
			dfs(next, me, list[me].dRoot+e.dist);
		}
	}

	// Solve the problem for me.
	public static void solve(int me) {

		// Base case where we are too far.
		if (list[me].par != -1 && 2*list[list[me].par].dRoot >= dist) {
			list[me].zeroAns = 0;
			list[me].oneAns = 0;
			return;
		}

		// Leaf Node base case.
		if (list[me].isLeaf()) {
			list[me].zeroAns = 0;
			list[me].oneAns = list[me].freeLight ? 0 : 1;
			return;
		}

		// Set these up based on root.
		list[me].zeroAns = 0;
		list[me].oneAns = list[me].freeLight ? 0 : 1;

		// First solve all subtrees and then accumulate results for us.
		for (int i=0; i<list[me].kids.size(); i++) {
			edge e = (edge)(list[me].kids.get(i));
			if (e.v1 == list[me].par || e.v2 == list[me].par) continue;
			int next = e.v1 == me ? e.v2 : e.v1;
			solve(next);
			list[me].zeroAns += list[next].oneAns;
			list[me].oneAns += Math.min(list[next].zeroAns, list[next].oneAns);
		}
	}
}

class edge {
	public int v1;
	public int v2;
	public int dist;

	public edge(int a, int b, int d) {
		v1 = a;
		v2 = b;
		dist = d;
	}
}

class node {

	public ArrayList<edge> kids;
	public int id;
	public int par;
	public int dRoot;
	public int zeroAns;
	public int oneAns;
	public boolean freeLight;

	public node(int i) {
		kids = new ArrayList<edge>();
		zeroAns = -1;
		oneAns = -1;
		dRoot = -1;
		par = -1;
		id = i;
		freeLight = false;
	}

	// Returns true iff this node is a leaf node.
	public boolean isLeaf() {
		if (par == -1)
			return kids.size() == 0;
		return kids.size() == 1;
	}
}