#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <climits>

using namespace std;

struct Node {
    int id;
    int color;
    vector<int> neighbors;
};

unordered_map<int, Node> nodes;

pair<int, int> dfs(int current, int parent, int targetColor, int distance) {
    Node& currentNode = nodes[current];
    int minDistance = INT_MAX;
    int maxDistance = 0;

    if (currentNode.color == targetColor) {
        minDistance = maxDistance = distance;
    }

    for (int neighbor : currentNode.neighbors) {
        if (neighbor != parent) {
            auto result = dfs(neighbor, current, targetColor, distance + 1);
            minDistance = min(minDistance, result.first);
            maxDistance = max(maxDistance, result.second);
        }
    }

    return {minDistance, maxDistance};
}

int main() {
    int n;
    cin >> n;

    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        nodes[u].neighbors.push_back(v);
        nodes[v].neighbors.push_back(u);
    }

    for (int i = 1; i <= n; ++i) {
        cin >> nodes[i].color;
        nodes[i].id = i;
    }

    int result = INT_MAX;

    for (int i = 1; i <= n; ++i) {
        auto distances = dfs(i, -1, nodes[i].color, 0);
        if (distances.first != distances.second) {
            result = min(result, distances.second - distances.first);
        }
    }

    if (result == INT_MAX) {
        cout << "-1 -1" << endl;
    } else {
        cout << result << endl;
    }

    return 0;
}