# include <bits/stdc++.h>
# define IL inline
# define RG register
# define Fill(a, b) memset(a, b, sizeof(a))
using namespace std;
typedef long long ll;

IL int Input(){
    RG int x = 0, z = 1; RG char c = getchar();
    for(; c < '0' || c > '9'; c = getchar()) z = c == '-' ? -1 : 1;
    for(; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
    return x * z;
}

const int maxn(1005);
const int inf(1e9);
const ll seed1(9377);
const ll seed2(10007);

namespace MCMF{
    int dis[maxn], pre1[maxn], pre2[maxn], vis[maxn], first[maxn], cnt, ans, s, t;
    queue <int> q;

    struct Edge{
        int to, next, f, w;
    } edge[maxn * maxn * 2];

    IL void Init(RG int a, RG int b){
        s = a, t = b, ans = cnt = 0;
        for(RG int i = a; i <= b; ++i) first[i] = -1;
    }
    
    IL void Add(RG int u, RG int v, RG int f, RG int w){
        edge[cnt] = (Edge){v, first[u], f, w}, first[u] = cnt++;
        edge[cnt] = (Edge){u, first[v], 0, -w}, first[v] = cnt++;
    }

    IL int Aug(){
        for(RG int i = s; i <= t; ++i) dis[i] = inf;
        q.push(s), dis[s] = 0, vis[s] = 1;
        while(!q.empty()){
            RG int u = q.front(); q.pop();
            for(RG int e = first[u]; e != -1; e = edge[e].next){
                RG int v = edge[e].to;
                if(edge[e].f && dis[v] > dis[u] + edge[e].w){
                    dis[v] = dis[u] + edge[e].w;
                    pre1[v] = e, pre2[v] = u;
                    if(!vis[v]) q.push(v), vis[v] = 1;
                }
            }
            vis[u] = 0;
        }
        if(dis[t] == inf) return 0;
        RG int ret = inf;
        for(RG int p = t; p; p = pre2[p]) ret = min(ret, edge[pre1[p]].f);
        ans += ret * dis[t];
        for(RG int p = t; p; p = pre2[p])
            edge[pre1[p]].f -= ret, edge[pre1[p] ^ 1].f += ret;
        return 1;
    }

    IL int Calc(){
        for(ans = 0; Aug(); );
        return ans;
    }
}

int cnt, first[maxn];

struct Edge{
    int to, next;
} edge[maxn << 1];

namespace Hash{
    struct Val{
        unsigned long long f1, f2;

        IL int operator ==(RG Val b) const{
            return f1 == b.f1 && f2 == b.f2;
        }
    } v[maxn];

    IL int Cmp(RG int a, RG int b){
        return v[a].f1 != v[b].f1 ? v[a].f1 < v[b].f1 : v[a].f2 < v[b].f2;
    }

    int size[maxn];

    IL void GetHash(RG int u, RG int ff){
        vector <int> son; son.clear(), size[u] = 1;
        for(RG int e = first[u]; e != -1; e = edge[e].next){
            RG int v = edge[e].to;
            if(v != ff){
                GetHash(v, u);
                size[u] += size[v], son.push_back(v);
            }
        }
        sort(son.begin(), son.end(), Cmp);
        for(RG int i = 0, l = son.size(); i < l; ++i){
            v[u].f1 = v[u].f1 * seed1 + v[son[i]].f1 * seed1 + v[son[i]].f2 * seed2;
            v[u].f2 = v[u].f2 * seed2 + v[son[i]].f1 * seed2 + v[son[i]].f2 * seed1;
        }
        v[u].f1 = v[u].f1 * seed1 + size[u];
        v[u].f2 = v[u].f2 * seed2 + size[u];
    }
};

int n, size[maxn], c1[maxn], c2[maxn], rt, tmp;
int f[maxn][maxn];

IL void Add(RG int u, RG int v){
    edge[cnt] = (Edge){v, first[u]}, first[u] = cnt++;
}

IL void GetRoot(RG int u){
    size[u] = 1; RG int mx = 0;
    for(RG int e = first[u]; e != -1; e = edge[e].next){
        RG int v = edge[e].to;
        if(!size[v]){
            GetRoot(v);
            size[u] += size[v];
            mx = max(mx, size[v]);
        }
    }
    mx = max(mx, n - size[u]);
    if((mx << 1) <= n){
        if(!rt) rt = u;
        else tmp = u;
    }
}

IL void Solve(RG int u1, RG int u2, RG int ff1, RG int ff2){
    f[u1][u2] = c1[u1] != c2[u2];
    vector <int> son1, son2; son1.clear(), son2.clear();
    for(RG int e = first[u1]; e != -1; e = edge[e].next)
        if(edge[e].to != ff1) son1.push_back(edge[e].to);
    for(RG int e = first[u2]; e != -1; e = edge[e].next)
        if(edge[e].to != ff2) son2.push_back(edge[e].to);
    RG int l1 = son1.size(), l2 = son2.size(), s = 0, t = l1 + l2 + 1;
    for(RG int i = 0; i < l1; ++i)
        for(RG int j = 0; j < l2; ++j)
            if(Hash::v[son1[i]] == Hash::v[son2[j]]) Solve(son1[i], son2[j], u1, u2);
    MCMF::Init(0, t);
    for(RG int i = 0; i < l1; ++i)
        for(RG int j = 0; j < l2; ++j)
            if(Hash::v[son1[i]] == Hash::v[son2[j]]) MCMF::Add(i + 1, j + 1 + l1, 1, f[son1[i]][son2[j]]);
    for(RG int i = 0; i < l1; ++i) MCMF::Add(s, i + 1, 1, 0);
    for(RG int i = 0; i < l2; ++i) MCMF::Add(i + 1 + l1, t, 1, 0);
    RG int ret = MCMF::Calc();
    f[u1][u2] += ret;
}

int main(){
    n = Input();
    for(RG int i = 1; i <= n + 1; ++i) first[i] = -1;
    for(RG int i = 1; i < n; ++i){
        RG int u = Input(), v = Input();
        Add(u, v), Add(v, u);
    }
    for(RG int i = 1; i <= n; ++i) c1[i] = Input();
    for(RG int i = 1; i <= n; ++i) c2[i] = Input();
    GetRoot(1);
    if(tmp){
        for(RG int e = first[rt]; e != -1; e = edge[e].next)
            if(edge[e].to == tmp) edge[e].to = n + 1;
        for(RG int e = first[tmp]; e != -1; e = edge[e].next)
            if(edge[e].to == rt) edge[e].to = n + 1;
        Add(n + 1, rt), Add(n + 1, tmp), rt = n + 1;
    }
    Hash::GetHash(rt, 0);
    Solve(rt, rt, 0, 0);
    printf("%d\n", f[rt][rt]);
    return 0;
}