class TaskE {
public:

	vector<vector<int>> g;

	vector<int> tin, tout;
	int timer = 0;
	vector<int> parent;
	void dfs(int v, int p) {
		tin[v] = timer++;
		for (int to: g[v]) {
			if (to != p) {
				parent[to] = v;
				dfs(to, v);
			}
		}
		tout[v] = timer;
	}
	void dfs2(int v, int p, vector<int64_t>& ans) {
		for (int to: g[v]) {
			if (to != p) {
				ans[to] += ans[v];
				dfs2(to, v, ans);
			}
		}
	}
	void solve(std::istream& in, std::ostream& out) {
		using Tree = TopDownSumSegmentTree<int64_t>;

		int n;
		in >> n;

		g.resize(n);
		tin.resize(n);
		tout.resize(n);
		parent.resize(n);

		vector<int> a(n);

		for (int i: range(n)) {
			in >> a[i];
		}
		for (int i: range(n - 1)) {
			int u, v;
			in >> u >> v;
			--u, --v;
			g[u].push_back(v);
			g[v].push_back(u);
		}

		vector<int64_t> almostAnswer(n);
		Tree cntBig(n);

		vector<int> indices(n);
		for (int i: range(n)) {
			indices[i] = i;
		}

		sort(indices, [&](int l, int r) {
			return a[l] > a[r];
		});

		dfs(0, -1);

		for (int i = 0; i < n;) {
			int j = i;
			while (j < n && a[indices[i]] == a[indices[j]]) {
				++j;
			}
			for (int k: range(i, j)) {
				int v = indices[k];
				int64_t othersBig = i;
				for (int to: g[v]) {
					if (to == parent[v]) {
						continue;
					}
					int64_t bigInSubtree = cntBig.getResult(tin[to], tout[to]);
					othersBig -= bigInSubtree;
					almostAnswer[0] += bigInSubtree;
					almostAnswer[to] -= bigInSubtree;
				}
				almostAnswer[v] += othersBig;
			}

			for (int k: range(i, j)) {
				int v = indices[k];
				cntBig.update(tin[v], tin[v] + 1, 1);
			}
			i = j;
		}

		dfs2(0, -1, almostAnswer);

		int best = 0;
		for (int i: range(n)) {
			if (almostAnswer[i] < almostAnswer[best]) {
				best = i;
			}
		}

		out << best + 1<< ' ' << almostAnswer[best] << "n";
	}
};