#pragma GCC optimize("Ofast")
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <assert.h>
#include <chrono>
#include <random>
#include <set>
#include <utility>
#include <array>
#include <bitset>
#include <unordered_set>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n; cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    vector<vector<int>> g(n);
    for (int i = 0; i < n - 1; ++i) {
        int x,y; cin >> x >> y;
        x--; y--;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    vector<vector<int>> dp(2, vector<int>(n));
    auto dfs = [&](auto dfs, int s, int p) -> void {
        vector<int> c;
        for (int t : g[s]) {
            if (t == p) continue;
            dfs(dfs, t, s);
            c.push_back(t);
        }
        if (c.size() == 0) {
            dp[0][s] = a[s];
            dp[1][s] = 1-a[s];
        }
        else {
            int mx = 1e9;
            int sum = 0;
            int bit = 0;
            for (auto t : c) {
                if (dp[0][t] > dp[1][t]) {
                    sum += dp[0][t];
                    mx = min(mx, dp[0][t]-dp[1][t]);
                }
                else {
                    sum += dp[1][t];
                    mx = min(mx, dp[1][t]-dp[0][t]);
                    bit ^= 1;
                }
            }
            int ad = (a[s]^bit);
            dp[bit][s] = sum+ad;
            dp[1-bit][s] = sum-mx+(1-ad);
        }
    };
    dfs(dfs, 0, -1);
    cout << max(dp[0][0], dp[1][0]) << endl;
}