// https://szkopul.edu.pl/problemset/problem/weKRWGa1NgLNHT1WLDo5ohuH/site/?key=statement

#include <bits/stdc++.h>

// Agenci

using namespace std;

#define int long long

constexpr int sizik = 1000 * 1001;

#define ar std::array
#define pr std::pair
#define vec std::vector

typedef vec<vec<int>> _kra;

constexpr int INF = 1000 * 1000 * 1001;
constexpr int NINF = -1000 * 1000 * 1001;

std::vector<int> kra[sizik];
bool agent[sizik];
int dp[sizik][3];

void DFS(int v, int p) {
    int D = 0;

    std::vector<int> q;
    for (const auto& u : kra[v]) {
        if (u == p) continue;
        DFS(u, v);
        D += dp[u][2];
        q.push_back(u);
    }

    if (agent[v]) {
        dp[v][0] = D;
        dp[v][1] = NINF;

        int r = NINF;
        for (const auto& u : q) {
            r = std::max(r, dp[u][1] - dp[u][2]);
        }

        dp[v][2] = std::max(D, D + 1 + r);
    } else {
        int r1 = NINF, r2 = NINF;
        std::vector<std::pair<int, int>> vr1, vr2;
        for (const auto& u : q) {
            int x = dp[u][0] - dp[u][2];
            r1 = std::max(r1, x);
            vr1.push_back({x, u});

            x = dp[u][1] - dp[u][2];
            r2 = std::max(r2, x);
            vr2.push_back({x, u});
        }

        std::sort(vr1.begin(), vr1.end(), std::greater<std::pair<int, int>>());
        std::sort(vr2.begin(), vr2.end(), std::greater<std::pair<int, int>>());

        dp[v][0] = D + 1 + r1;
        dp[v][1] = std::max(D, D + 1 + r2);

        int m = (int)q.size();
        dp[v][2] = std::max(D, dp[v][0]);
        if (m == 0) {
            ;
        } else if (m == 1) {
            ;
        } else {
            auto y1 = vr1[0];
            auto y2 = vr2[0];
            if (y1.second == y2.second) {
                y2 = vr2[1];
            }

            dp[v][2] = std::max(dp[v][2], y1.first + y2.first + D + 2);

            y1 = vr1[0];
            y2 = vr2[0];
            if (y1.second == y2.second) {
                y1 = vr1[1];
            }

            dp[v][2] = std::max(dp[v][2], y1.first + y2.first + D + 2);
        }
    }
}

void solve() {
    int n, k;
    std::cin >> n >> k;

    for (int i = 1; i <= k; i++) {
        int a;
        std::cin >> a;

        agent[a] = true;
    }

    for (int i = 1; i < n; i++) {
        int a, b;
        std::cin >> a >> b;

        kra[a].push_back(b);
        kra[b].push_back(a);
    }

    DFS(1, 1);

    for (int i = 1; i <= n; i++) {
    }

    int ans = 2 * (n - k) - dp[1][2];

    std::cout << ans << '\n';
}

int32_t main() {
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}