#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define per(i, a, b) for (int i = int(b)-1; i >= int(a); i--)
#define trav(a, x) for (auto& a : x)
#define sz(x) int(x.size())
#define all(x) x.begin(), x.end()

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;
using pii = pair<int, int>;

mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());

template <class F>
struct ycr {
	F f;
	template <class T> explicit ycr(T&& ff) : f(forward<T>(ff)) {}
	template <class... A> decltype(auto) operator()(A&&... args) {
		return f(ref(*this), forward<A>(args)...);
	}
};

template <class F> decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

struct GC {
	char buf[1<<16];
	size_t s=0,e=0;
	char operator()(){
		if(s>=e){
			buf[0]=0;
			s=0;
			e=fread(buf,1,sizeof(buf),stdin);
		}
		return buf[s++];
	}
} gc;
int read() {
	char c;
	while((c=gc())<40);
	if(c==-'-')return -read();
	int a=c-'0';
	while(isdigit(c=gc()))a=a*10+c-'0';
	return a;
}

struct hldecomp {
	int n;
	vi ord;
	vc<array<int,2>> idx;
	vc<pair<int,int>> heavy;
	hldecomp():n(0){}
	hldecomp(const vi&par):n(sz(par)),ord(n),idx(n),heavy(n){
		vvc<int> ch(n);
		for (int i = 0; i < n; i++) {
			if (par[i] != -1) {
				ch[par[i]].push_back(i);
			}
		}
		vi s(n);
		int nidx = 0;
		for (int i = 0; i < n; i++) {
			if (par[i] != -1) continue;
			yc([&](auto self, int v) -> void {
				s[v] = 1;
				for (int w : ch[v]) {
					self(w);
					s[v] += s[w];
				}
				if (!ch[v].empty()) {
					auto mit = max_element(ch[v].begin(), ch[v].end(), [&](int a, int b) {
						return s[a] < s[b];
					});
					swap(*ch[v].begin(), *mit);
				}
			})(i);
			yc([&](auto self, int v, bool rt = true) -> void {
				ord[idx[v][0] = nidx++] = v;
				if (rt) {
					heavy[idx[v][0]] = {par[v] == -1 ? -1 : idx[par[v]][0], 1};
				} else {
					assert(idx[par[v]][0] == idx[v][0]-1);
					heavy[idx[v][0]] = heavy[idx[v][0]-1];
					heavy[idx[v][0]].second++;
				}
				bool crt = false;
				for (int w : ch[v]) {
					self(w, crt);
					crt = true;
				}
				idx[v][1] = nidx;
			})(i);
		}
		assert(n == nidx);
	}

	int lca(int a, int b) {
		a = idx[a][0], b = idx[b][0];
		while (true) {
			if (a > b) swap(a, b);
			assert(a <= b);
			if (a > b - heavy[b].second) {
				return ord[a];
			}
			b = heavy[b].first;
			if (b == -1) return -1;
		}
	}

	bool in_subtree(int a, int p) const {
		return idx[p][0] <= idx[a][0] &&
			idx[a][1] <= idx[p][1];
	}
};

const int MAXV = 2.5e7;
struct seg {
	array<int, 2> c;
	int v;
} pool[MAXV];

template <class T> void setmax(T& a, const T& b) {
	if (a < b) a = b;
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int N;
	cin >> N;
	vector<vector<int>> locs(N);
	for (int i = 0; i < N; i++) {
		int c;
		cin >> c;
		c--;
		locs[c].push_back(i);
	}

	vector<vector<int>> adj(N);
	for (int e = 0; e < N-1; e++) {
		int a, b;
		cin >> a >> b;
		a--, b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}

	vector<int> par(N, -1);
	vector<int> depth(N, 0);
	yc([&](auto self, int cur, int prv, int d) -> void {
		par[cur] = prv;
		depth[cur] = d;
		for (int nxt : adj[cur]) {
			if (nxt == prv) continue;
			self(nxt, cur, d+1);
		}
	})(0, -1, 0);
	auto hld = hldecomp(par);

	vector<tuple<int, int, int>> stuff;
	stuff.reserve(N/2);
	for (int c = 0; c < N; c++) {
		if (locs[c].size() <= 1) continue;
		assert(locs[c].size() == 2);
		int x = locs[c][0];
		int y = locs[c][1];
		int a = hld.lca(x, y);
		int d = depth[x] + depth[y] - 2 * depth[a];
		stuff.emplace_back(d, x, y);
	}

	const int S = 1 << (N <= 1 ? 0 : 32 - __builtin_clz(N-1));
	vector<int> seg(2*S);
	int V = 1;
	auto upd_inner = [&](int& rt, int k, int v) -> void {
		yc([&](auto self, int& a, int l, int r) -> void {
			if (!a) {
				assert(V < MAXV);
				a = V++;
				pool[a].c = {0,0};
				pool[a].v = 0;
			}
			assert(a);
			setmax(pool[a].v, v);

			if (r-l == 1) {
				return;
			}

			int m = (l+r)/2;
			if (k < m) {
				self(pool[a].c[0], l, m);
				assert(pool[a].c[0]);
			} else {
				self(pool[a].c[1], m, r);
				assert(pool[a].c[1]);
			}

			assert(pool[a].v >= v);
		})(rt, 0, S);
	};
	auto upd_outer = [&](int x, int y, int v) -> void {
		assert(0 <= x && x < S);
		assert(0 <= y && y < S);
		for (int a = S+x; a >= 1; a /= 2) {
			upd_inner(seg[a], y, v);
			assert(seg[a]);
		}
	};

	auto query_inner = [&](int rt, int ql, int qr) -> int {
		return yc([&](auto self, int a, int l, int r) -> int {
			if (!a) return 0;
			if (r <= ql || qr <= l) return 0;
			if (ql <= l && r <= qr) {
				return pool[a].v;
			}
			int m = (l+r)/2;
			return max(self(pool[a].c[0], l, m), self(pool[a].c[1], m, r));
		})(rt, 0, S);
	};
	auto query_outer = [&](int xl, int xr, int yl, int yr) -> int {
		assert(0 <= xl);
		assert(xl <= xr);
		assert(xr <= yl);
		assert(yl <= yr);
		assert(yr <= S);
		if (xl == xr) return 0;
		if (yl == yr) return 0;
		int res = 0;
		for (int a = S+xl, b = S+xr; a < b; a /= 2, b /= 2) {
			if (a & 1) setmax(res, query_inner(seg[a++], yl, yr));
			if (b & 1) setmax(res, query_inner(seg[--b], yl, yr));
		}
		return res;
	};

	const auto& idx = hld.idx;

	sort(stuff.begin(), stuff.end());
	reverse(stuff.begin(), stuff.end());
	int ans = 1;
	for (auto [d, x, y] : stuff) {
		assert(x != y);

		int v;
		if (idx[x][0] > idx[y][0]) swap(x, y);
		int a = hld.lca(x, y);
		if (a != x) {
			v = query_outer(idx[x][0], idx[x][1], idx[y][0], idx[y][1]);
		} else {
			int c = -1;
			for (int z : adj[x]) {
				if (hld.in_subtree(y, z)) {
					c = z;
					break;
				}
			}
			assert(c != -1);
			v = query_outer(0, idx[c][0], idx[y][0], idx[y][1]);
			setmax(v, query_outer(idx[y][0], idx[y][1], idx[c][1], N));
		}
		v += 2;

		setmax(ans, v + int(d >= 2));

		upd_outer(idx[x][0], idx[y][0], v);
	}
	cout << ans << '\n';
}