#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <deque>
#include <set>
#include <map>
#include <algorithm>

#include <cmath>
#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
using namespace std;

const int INF = 0x3f3f3f3f;
const double EPS = 1e-11;
const double PI = 3.141592653589793;
const int MAX_N = 20005;
const int MAX_K = 305;
const long long LLINF = 99999999999999999LL;
const int SIGMA = 26;

const int SOURCE = 301;
const int SINK = 302;

int N, K, nr, ans, T;
int a[MAX_K], b[MAX_K], L[MAX_K], R[MAX_K], Cost[MAX_K][MAX_K];
int Lv[MAX_N], E[2 * MAX_N], val[2 * MAX_N], pos[MAX_N], Log2[2 * MAX_N], RMQ[2 * MAX_N][20];
vector < int > w[MAX_K], v[MAX_K];
bool vis[MAX_N], used[MAX_K];

void DFS(int x, int level) {
    vis[x] = 1;
    Lv[x] = level;
    ++nr;
    E[nr] = x, val[nr] = level, pos[x] = nr;
    for(int i = 0; i < (int) w[x].size(); ++i) {
        if(vis[w[x][i]])
            continue;

        DFS(w[x][i], level + 1);
        ++nr;
        E[nr] = x, val[nr] = level;
    }
}

void ComputeRMQ() {
    int n = 2 * N - 1;

    for(int i = 1; i <= n; ++i)
        RMQ[i][0] = i;

    for(int j = 1; (1 << j) <= n; ++j)
        for(int i = 1; i + (1 << j) - 1 <= n; ++i) {
            if(val[RMQ[i][j - 1]] < val[RMQ[i + (1 << (j - 1))][j - 1]])
                RMQ[i][j] = RMQ[i][j - 1];
            else RMQ[i][j] = RMQ[i + (1 << (j - 1))][j - 1];
        }
}

int LCA(int x, int y) {
    x = pos[x], y = pos[y];

    if(x > y)
        swap(x, y);

    int k = Log2[y - x + 1];

    if(val[RMQ[x][k]] < val[RMQ[y - (1 << k) + 1][k]])
        return E[RMQ[x][k]];
    else return E[RMQ[y - (1 << k) + 1][k]];
}

inline bool pair_up(int x) {
    if(used[x])
        return 0;

    used[x] = 1;
    for(size_t i = 0; i < v[x].size(); ++i) {
        int y  = v[x][i];

        if(Cost[x][y] > T)
            continue;

        if(!R[y] || pair_up(R[y])) {
            L[x] = y;
            R[y] = x;
            return 1;
        }
    }
    return 0;
}

int main() {
    /*
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
    #endif
    */

    for(int i = 2; i < 2 * MAX_N; ++i)
        Log2[i] = Log2[i / 2] + 1;

    scanf("%d %d", &N, &K);
    for(int i = 1; i <= K; ++i)
        scanf("%d", &a[i]);
    for(int i = 1; i <= K; ++i)
        scanf("%d", &b[i]);

    for(int i = 1; i < N; ++i) {
        int x, y;

        scanf("%d %d", &x, &y);

        w[x].push_back(y);
        w[y].push_back(x);
    }

    DFS(1, 1);
    ComputeRMQ();

    int maxVal = 0;
    for(int i = 1; i <= K; ++i) {
        for(int j = 1; j <= K; ++j) {
            int z = LCA(a[i], b[j]);

            v[i].push_back(j);
            Cost[i][j] = Lv[a[i]] - Lv[z] + Lv[b[j]] - Lv[z];

            maxVal = max(maxVal, Cost[i][j]);
        }
    }

    for(int l = 0, m = 0, r = maxVal; l <= r; ) {
        m = (l + r) / 2;
        T = m;

        for(int i = 1; i <= K; ++i)
            L[i] = R[i] = 0;

        int now = 0;
        bool ok = 1;
        while(ok) {
            for(int i = 1; i <= K; ++i)
                used[i] = 0;

            ok = 0;
            for(int i = 1; i <= K; ++i) {
                if(!L[i] && pair_up(i)) {
                    ok = 1;
                    ++now;
                }
            }
        }

        if(now == K) {
            ans = m;
            r = m - 1;
        }
        else l = m + 1;
    }

    printf("%d\n", ans);

    return 0;
}