#include <iostream>
#include <fstream>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>

using namespace std;


void add_edge(vector <vector <int>> &graph, int node1, int node2)
{
    graph[node1].push_back(node2);
}

void add_weighted_edge(vector <vector <pair <int,int>>> &graph, int node1, int node2, int weight)
{
    graph[node1].push_back(make_pair(node2, weight));
}

void dfs(vector <vector <int>> graph, int starting_node, vector <int>& result)
{
    vector <int> stk;
    stk.push_back(starting_node);
    while(!stk.empty())
    {

        int node = stk[stk.size() - 1];
        int in_result = 0;
        stk.pop_back();
        for(int i = 0; i < result.size(); i++)
        {
            if(result[i] == node)
                in_result = 1;
        }
        if(in_result == 1)
        {
            continue;
        }
        result.push_back(node);
        for(auto neighbour: graph[node])
        {
            stk.push_back(neighbour);
        }
    }
}

void dfs_connected(vector <vector <int>> graph, int N, vector <vector <int>>& components)
{
    vector <int> visited, result_dfs;
    visited.resize(N+1);
    for (int nod = 1; nod <= N; nod++)
    {
        if(visited[nod] == 0)
        {
            result_dfs.clear();
            dfs(graph, nod, result_dfs);
            components.push_back(result_dfs);
            for(int j = 0; j <= result_dfs.size(); j++)
            {
                visited[result_dfs[j]] = 1;
            }
        }
    }
}

int conexidad(vector <vector <int>> graph, vector <vector <int>>& added_edges, int N, vector <vector <int>> components)
{
   vector <int> extra;
   int first_node, second_node;
   for(int i = 0; i < N; i++)
   {
       extra.push_back(0);
   }
   for (int current_index = 0; current_index < components.size() - 1; current_index++)
   {
        first_node = components[current_index][0];
        int next = components[current_index+1].size() - 1;
        second_node = components[current_index+1][next];
        extra[first_node-1] += 1;
        extra[second_node-1] += 1;
        added_edges.push_back({first_node, second_node});
   }
   return *max_element(extra.begin(), extra.end());
}

void amici_bfs(vector <vector <int>> graph, int starting_node, int& maximum, int N)
{
    queue <int> que;
    vector <int> visited;
    que.push(starting_node);
    visited.resize(N+1);
    visited[starting_node] = 1;
    while(!que.empty())
    {
        int current_node = que.front();
        que.pop();
        for(auto neighbour: graph[current_node])
        {
            if(!visited[neighbour])
            {
                visited[neighbour] = visited[current_node] + 1;
                que.push(neighbour);
                maximum = max(maximum, visited[neighbour]);
            }
        }
    }
}
bool sort_by_weight(vector <int> pair1, vector <int> pair2)
{
    return (pair1[2] > pair2[2]);
}

int transport(vector <vector <pair <int,int>>> graph, int N)
{
    int current_max, trans_min = 10001;
    vector <vector <int>> edges;
    vector <vector <int>> components;
    for(int i = 1; i <= N; i++)
    {
        for(auto edge : graph[i])
        {
            edges.push_back({i, edge.first, edge.second});
        }
    }
    sort(edges.begin(), edges.end(), sort_by_weight);
    components.push_back({edges[0][0], edges[0][1]});
    for(int i = 1; i < edges.size(); i++)
    {
        int index_first_node = -1, index_second_node = -1;
        for(int index = 0; index < components.size(); index++)
        {
            for(auto node: components[index])
            {
                if(node == edges[i][0])
                {
                    index_first_node = index;
                }
                if(node == edges[i][1])
                {
                    index_second_node = index;
                }
            }
        }
        if(index_first_node == index_second_node && index_first_node != -1)
        {
            continue;
        }
        if(index_first_node == -1 && index_second_node == -1)
        {
            //daca nu am gasit nodurile in nicio componenta conexa,
            //nodurile vor forma o noua componenta conexa
            components.push_back({edges[i][0], edges[i][1]});
            if(edges[i][2] < trans_min)
                trans_min = edges[i][2];
        }
        else if(index_first_node == -1)
        {
           components[index_second_node].push_back(edges[i][0]);
            if(edges[i][2] < trans_min)
                trans_min = edges[i][2];
        }
        else if(index_second_node == -1)
        {
            components[index_first_node].push_back(edges[i][1]);
            if(edges[i][2] < trans_min)
                trans_min = edges[i][2];
        }
        else
        {
            if(components[index_first_node].size() < components[index_second_node].size())
            {
               for(auto node: components[index_first_node])
                {
                    components[index_second_node].push_back(node);
                }
                components[index_first_node].clear();
                if(edges[i][2] < trans_min)
                trans_min = edges[i][2];
            }
            else
            {
                for(auto node: components[index_second_node])
                {
                    components[index_first_node].push_back(node);
                }
                components[index_second_node].clear();
                if(edges[i][2] < trans_min)
                trans_min = edges[i][2];
            }
        }
    }
    return trans_min;
}


ifstream f("asmax.in");
ofstream f_out("asmax.out");
vector <vector <int>> my_graph;
vector <int> values;
vector <int> dfs_visited;
vector <int> sums;
int N, M, x, y, z, sum_max;

void dfs_asmax(vector <vector <int>> graph, int current_node)
{
    dfs_visited[current_node] = 1;
    sums[current_node] = values[x];

    for(auto node : graph[current_node])
    {
        if(!dfs_visited[node])
        {
            dfs_asmax(graph, node);
            sums[current_node] = max(sums[current_node], sums[node] + sums[current_node]);
        }
    }
}

int asmax(vector <vector <int>> graph, int N)
{
    dfs_asmax(graph, 1);
    int s_max = INT_MIN;
    for(int i = 1; i <= N; ++i)
    {
        if(s_max < sums[i])
        {
            s_max = sums[i];
        }
    }
    return s_max;
}

int main()
{
    f >> N;
    my_graph.resize(N+1);
    values.push_back(0);
    dfs_visited.resize(N+5);
    sums.resize(N+5);
    for (int i = 0; i < N; i++)
    {
        f >> x;
        values.push_back(x);
    }
    for (int i = 0; i < N-1; i++)
    {
        f >> x >> y;
        add_edge(my_graph, x, y);
        add_edge(my_graph, y, x);
    }
    sum_max = asmax(my_graph, N);
    f_out << sum_max;
}