import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Random;
import java.util.StringTokenizer;


public class CutTreeFull {

	static HashMap<Integer, HashSet<Integer>> G = new HashMap<>();
	static HashMap<Integer, Long> vertexCost = new HashMap<>();
	static HashMap<Integer, Long> vertexSum = new HashMap<>();
	static HashMap<Integer, Integer> visitedOrder = new HashMap<>();
	static HashSet<Integer> visited = new HashSet<>();
	static int n;
	static int[] fr;
	static int[] to;
	static long totalSum = 0;
	static int orderIndex = 0;

	static void addDirectedEdge(int u, int v) {
		HashSet<Integer> ady = G.getOrDefault(u, null);
		if (ady == null) {
			ady = new HashSet<>();
		}
		ady.add(v);
		G.put(u, ady);
	}

	static void addUndirectedEdge(int u, int v) {
		addDirectedEdge(u, v);
		addDirectedEdge(v, u);
	}

	static long DFS(int root) {
		long sum = vertexCost.get(root);
		visitedOrder.put(root, orderIndex ++);
		visited.add(root);
		for (int v : G.get(root)) {
			if (!visited.contains(v)) {
				sum += DFS(v);
			}
		}
		vertexSum.put(root, sum);
		return sum;
	}

	static void solve(PrintWriter out) {
		long sol = Long.MAX_VALUE;
		Random r = new Random();
		int root = r.nextInt(n) + 1;
		DFS(root);
		for (int i = 0; i < n-1; ++ i) {
			int u = fr[i];
			int v = to[i];
			if (visitedOrder.get(v) < visitedOrder.get(u)) {
				int temp = u;
				u = v;
				v = temp;
			}
			long vSum = vertexSum.get(v);
			long rest = totalSum - vSum;
			sol = Math.min(sol, Math.abs(rest - vSum));
		}
		out.println(sol);
		out.close();
	}

	public static void main(String[] args) throws IOException {

		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

		n = Integer.parseInt(in.readLine());

		fr = new int[n-1];
		to = new int[n-1];

		StringTokenizer st = new StringTokenizer(in.readLine());
		for (int i = 0; i < n; ++ i) {
			long c = Long.parseLong(st.nextToken());
			vertexCost.put(i+1, c);
			totalSum += c;
		}

		for (int i = 0; i < n-1; ++ i) {
			st = new StringTokenizer(in.readLine());
			int u = Integer.parseInt(st.nextToken());
			int v = Integer.parseInt(st.nextToken());
			fr[i] = u;
			to[i] = v;
			addUndirectedEdge(u, v);
		}

		solve(out);

	}

}