#include <iostream>
#include <fstream>

#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#if __cplusplus > 199711L
#include <unordered_map>
#include <unordered_set>
#endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstring>
#include <cstdlib>

using namespace std;

typedef long long int64;

ifstream fin("asmax.in");
ofstream fout("asmax.out");

const int NMAX = 16010, inf = 0x3f3f3f3f;

int N, max_arb = -inf;
int v[NMAX], best[NMAX];
vector<int> G[NMAX], order;
bool visited[NMAX];

void DFS(const int &vertex)
{
    visited[vertex] = true;
    for (size_t i = 0; i < G[vertex].size(); ++i)
        if (!visited[G[vertex][i]])
            DFS(G[vertex][i]);
    order.push_back(vertex);
}

int main()
{
    int i, x, y;
    size_t j;

    fin >> N;
    for (i = 1; i <= N; ++i)
        fin >> v[i];

    for (i = 1; i < N; ++i)
    {
        fin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }

    DFS(1);
    memset(visited, 0, sizeof(visited));

    for (j = 0; j < order.size(); ++j)
    {
        best[order[j]] = v[order[j]];
        max_arb = max(max_arb, best[order[j]]);
        for (size_t k = 0; k < G[order[j]].size(); ++k)
        {
            if (!visited[G[order[j]][k]]) continue;
            best[order[j]] = max(best[order[j]], best[order[j]] + best[G[order[j]][k]]);
            max_arb = max(max_arb, best[order[j]]);
        }
        visited[order[j]] = true;
    }

    fout << max_arb << '\n';

	fin.close();
	fout.close();
	return 0;
}