#include <iostream>
#include <iomanip>
#include <algorithm>
#include <utility>
#include <sstream>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <map>
#include <set>
#include <stack>
#include <fstream>
#include <chrono>
using namespace std;
using namespace std::chrono;

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<ull> vull;
typedef vector<vull> vvull;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;

#define fs first
#define sc second
#define pb push_back
// forward strict for, most common
#define fors(i, a, n) for (int i = (int) (a); i < (int) (n); ++i)
// forward inclusive for
#define fori(i, a, n) for (int i = (int) (a); i <= (int) (n); ++i)
// backward for, inclusive
#define forb(i, n, a) for (int i = (int) n; i >= a; --i)

class Problem {
public:
    int n;
    vint sm;
    vint a;
    vvint adj;
    vint dp;
    int lmin = numeric_limits<int>::min();

    void solve() {
        ifstream in("asmax.in");
        ofstream out("asmax.out");

        int n;
        in >> n;
        sm = vint(n + 1, lmin);
        a = vint(n + 1);
        
        fori(i, 1, n)
            in >> a[i];
        adj = vvint(n + 1);
        fors(i, 1, n)
        {
            int u, v;
            in >> u >> v;
            adj[u].push_back(v);
            adj[v].push_back(u);
        }

        int smax = lmin;
        fori(i, 1, n)
        {
            dp = vint(n + 1, lmin);
            sm[i] = fdp(i);
            smax = max(smax, sm[i]);
//            printf("%d as root: ", i);
//            fori(i, 1, n) cout << dp[i] << " ";
//            cout << endl;
        }
        
        out << smax << endl;
    }
    
    int fdp(int u) {
        if (dp[u] != lmin) return dp[u];
//        cout << "fdp " << u << endl;
        
        dp[u] = a[u];
        for (int v : adj[u]) {
            if (dp[v] != lmin) continue;
            int dpv = fdp(v);
            if (dpv >= 0) dp[u] += dpv;
        }
        
        return dp[u];
    }
};

int main() {
    Problem p;
    p.solve();

    return 0;
}