#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

typedef long long ll;

ll solve(int n, vector<ll>& capacities, vector<pair<int, int>>& edges) {
    if (n == 0) return 0;
    
    vector<vector<int>> adj(n + 1);
    for (auto& e : edges) {
        int u = e.first, v = e.second;
        adj[u].push_back(v);
    }

    vector<ll> maxCargo(n + 1, 0);
    
    function<void(int)> dfs = [&](int node) {
        if (adj[node].empty()) {
            maxCargo[node] = capacities[node];
            return;
        }
        
        ll sumChildren = 0;
        for (int child : adj[node]) {
            dfs(child);
            sumChildren += maxCargo[child];
        }
        
        maxCargo[node] = min(capacities[node], sumChildren);
    };

    dfs(1);
    return maxCargo[1];
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    if (!(cin >> n)) return 0;

    vector<ll> capacities(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> capacities[i];
    }

    vector<pair<int, int>> edges;
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        edges.push_back({u, v});
    }

    cout << solve(n, capacities, edges) << endl;

    return 0;
}

import java.util.*;
import java.io.*;

public class Main {
    public static long solve(int n, long[] capacities, int[][] edges) {
        if (n == 0) return 0L;
        
        List<List<Integer>> adj = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
        }
        
        for (int[] e : edges) {
            adj.get(e[0]).add(e[1]);
        }
        
        long[] maxCargo = new long[n + 1];
        
        dfs(1, adj, capacities, maxCargo);
        
        return maxCargo[1];
    }
    
    private static void dfs(int node, List<List<Integer>> adj, long[] capacities, long[] maxCargo) {
        if (adj.get(node).isEmpty()) {
            maxCargo[node] = capacities[node];
            return;
        }
        
        long sumChildren = 0;
        for (int child : adj.get(node)) {
            dfs(child, adj, capacities, maxCargo);
            sumChildren += maxCargo[child];
        }
        
        maxCargo[node] = Math.min(capacities[node], sumChildren);
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        
        st = new StringTokenizer(br.readLine());
        long[] capacities = new long[n + 1];
        for (int i = 1; i <= n; i++) {
            capacities[i] = Long.parseLong(st.nextToken());
        }
        
        int[][] edges = new int[n - 1][2];
        for (int i = 0; i < n - 1; i++) {
            st = new StringTokenizer(br.readLine());
            edges[i][0] = Integer.parseInt(st.nextToken());
            edges[i][1] = Integer.parseInt(st.nextToken());
        }
        
        System.out.println(solve(n, capacities, edges));
    }
}

def solve(n, capacities, edges):
    if n == 0:
        return 0
    
    adj = [[] for _ in range(n + 1)]
    for u, v in edges:
        adj[u].append(v)
    
    maxCargo = [0] * (n + 1)
    
    def dfs(node):
        if not adj[node]:
            maxCargo[node] = capacities[node]
            return
        
        sumChildren = 0
        for child in adj[node]:
            dfs(child)
            sumChildren += maxCargo[child]
        
        maxCargo[node] = min(capacities[node], sumChildren)
    
    dfs(1)
    return maxCargo[1]

if __name__ == "__main__":
    import sys
    input_data = sys.stdin.read().split()
    idx = 0
    n = int(input_data[idx]); idx += 1
    capacities = [0] + [int(input_data[idx + i]) for i in range(n)]; idx += n
    edges = []
    for _ in range(n - 1):
        u = int(input_data[idx]); idx += 1
        v = int(input_data[idx]); idx += 1
        edges.append((u, v))
    
    print(solve(n, capacities, edges))

/**
 * @param {number} n - Number of nodes.
 * @param {number[]} capacities - Array of node capacities (1-indexed).
 * @param {number[][]} edges - Array of edges [parent, child].
 * @return {number} Maximum cargo amount.
 */
function solve(n, capacities, edges) {
    if (n === 0) return 0;

    const adj = Array.from({ length: n + 1 }, () => []);
    for (const [u, v] of edges) {
        adj[u].push(v);
    }

    const maxCargo = new Array(n + 1).fill(0);

    const dfs = (node) => {
        if (adj[node].length === 0) {
            maxCargo[node] = capacities[node];
            return;
        }

        let sumChildren = 0;
        for (const child of adj[node]) {
            dfs(child);
            sumChildren += maxCargo[child];
        }

        maxCargo[node] = Math.min(capacities[node], sumChildren);
    };

    dfs(1);
    return maxCargo[1];
}

// Driver code
const fs = require('fs');
const input = fs.readFileSync(0, 'utf8').split(/\s+/).map(Number);
let idx = 0;
const n = input[idx++];
const capacities = [0];
for (let i = 0; i < n; i++) {
    capacities.push(input[idx++]);
}
const edges = [];
for (let i = 0; i < n - 1; i++) {
    const u = input[idx++];
    const v = input[idx++];
    edges.push([u, v]);
}

console.log(solve(n, capacities, edges));