#include <bits/stdc++.h>


using namespace std;


#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()


const ll inf = 1e18;
mt19937 rnd(234);


struct SGT_mx {
    int n;
    vector<int> t;


    void build(int _n) {
        n = 1;
        while (n < _n) {
            n *= 2;
        }
        t.assign(n * 2, 0);
    }


    void change(int i, int x) {
        i += n;
        for (; i >= 1; i /= 2) {
            t[i] = max(t[i], x);
        }
    }


    int get(int l, int r) {
        l += n;
        r += n + 1;
        int rs = 0;
        while (l < r) {
            if (l & 1) {
                rs = max(rs, t[l]);
                l += 1;
            }
            if (r & 1) {
                r -= 1;
                rs = max(rs, t[r]);
            }
            l /= 2;
            r /= 2;
        }
        return rs;
    }
};


struct SGT_2d {
    int n;
    vector<vector<int>> p;
    vector<SGT_mx> t;


    void build(vector<vector<int>> a) {
        n = 1;
        while (n < (int)a.size()) {
            n *= 2;
        }
        p.assign(n * 2, vector<int>());
        t.resize(n * 2);
        for (int i = 0; i < (int)a.size(); i += 1) {
            p[i + n] = a[i];
            sort(all(p[i + n]));
            p[i + n].resize(unique(all(p[i + n])) - p[i + n].begin());
        }
        for (int i = n - 1; i >= 1; i -= 1) {
            p[i].resize(p[i + i].size() + p[i + i + 1].size());
            merge(all(p[i + i]), all(p[i + i + 1]), p[i].begin());
            p[i].resize(unique(all(p[i])) - p[i].begin());
        }
        for (int i = 1; i < n * 2; i += 1) {
            t[i].build((int)p[i].size());
        }
    }


    void change(int x, int y, int val) {
        x += n;
        for (; x >= 1; x /= 2) {
            int i = lower_bound(all(p[x]), y) - p[x].begin();
            t[x].change(i, val);
        }
    }


    int get(int lx, int rx, int ly, int ry) {
        lx += n;
        rx += n + 1;
        int rs = 0;
        while (lx < rx) {
            if (lx & 1) {
                int l = lower_bound(all(p[lx]), ly) - p[lx].begin();
                int r = upper_bound(all(p[lx]), ry) - p[lx].begin() - 1;
                rs = max(rs, t[lx].get(l, r));
                lx += 1;
            }
            if (rx & 1) {
                rx -= 1;
                int l = lower_bound(all(p[rx]), ly) - p[rx].begin();
                int r = upper_bound(all(p[rx]), ry) - p[rx].begin() - 1;
                rs = max(rs, t[rx].get(l, r));
            }
            lx /= 2;
            rx /= 2;
        }
        return rs;
    }
};

int n;
vector<int> c;
vector<vector<int>> g;
vector<vector<int>> f;
vector<int> tin, tout;
vector<int> e;
vector<int> par;


void dfs(int v, int p) {
    par[v] = p;
    tin[v] = (int)e.size();
    e.push_back(v);
    for (auto to : g[v]) {
        if (to == p) {
            continue;
        }
        dfs(to, v);
    }
    tout[v] = (int)e.size();
}


bool is_son(int v, int p) {
    return tin[p] <= tin[v] and tin[v] < tout[p];
}

int solve() {
    tin.resize(n);
    tout.resize(n);
    e.clear();
    e.reserve(n);
    par.resize(n);
    dfs(0, -1);
    f.assign(n, vector<int>());
    for (auto v : e) {
        f[c[v]].push_back(v);
    }
    int rs = 1;
    sort(all(f), [&](const vector<int>& a, const vector<int>& b) {
        if ((int)a.size() != (int)b.size()) {
            return (int)a.size() < (int)b.size();
        }
        if ((int)a.size() != 2) {
            return false;
        }
        int u = a[0], v = a[1];
        int s = b[0], t = b[1];
        bool para = is_son(u, v) || is_son(v, u);
        bool parb = is_son(s, t) || is_son(t, s);
        if (para != parb) {
            return para < parb;
        }
        if (para) {
            return abs(tin[u] - tin[v]) > abs(tin[s] - tin[t]);
        }
        return tin[u] < tin[s];
        });
    vector<array<int, 3>> aboba;
    SGT_2d sgt;
    vector<vector<int>> sgt_init(n);
    for (auto x : f) {
        if ((int)x.size() != 2) {
            continue;
        }
        int u = x[0], v = x[1];
        sgt_init[tin[u]].push_back(tin[v]);
    }
    sgt.build(sgt_init);
    auto add_point = [&](int x, int y, int val) {
        sgt.change(x, y, val);
        };
    auto get = [&](int lx, int rx, int ly, int ry) {
        return sgt.get(lx, rx, ly, ry);
        };
    for (auto x : f) {
        if ((int)x.size() != 2) {
            continue;
        }
        int u = x[0], v = x[1];
        int mx = 2;
        if (is_son(v, u)) {
            mx = max(mx, get(0, tin[u] - 1, tin[v], tout[v] - 1) + 2);
            mx = max(mx, get(tin[v], tout[v] - 1, tout[u], n - 1) + 2);
        } else {
            mx = max(mx, get(tin[u], tout[u] - 1, tin[v], tout[v] - 1) + 2);
        }
        if (par[v] == u) {
            rs = max(rs, mx);
        } else {
            rs = max(rs, mx + 1);
        }
        add_point(tin[u], tin[v], mx);
    }
    return rs;
}


int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n;
    c.resize(n);
    for (int i = 0; i < n; i += 1) {
        cin >> c[i];
        --c[i];
    }
    g.assign(n, vector<int>());
    for (int i = 0; i < n - 1; i += 1) {
        int u, v;
        cin >> u >> v;
        --u;
        --v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    int rs = solve();
    cout << rs << "\n";
    return 0;
}