#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <cassert>
using namespace std;
#define INF 1LL<<60

int N;
vector<long long> A;
vector<vector<int>> G;
long long dp[5555][2][5555];
int sz[5555];

void dfs(int s, int p){
    sz[s] = 1;
    dp[s][1][0] = A[s];
    if(A[s] > 0) dp[s][0][0] = A[s];

    for(int t : G[s]){
        if(t == p) continue;
        dfs(t, s);
        if(A[s] > 0){
            vector<long long> v(sz[s]+sz[t]+2, INF);

            for(int i=0; i<=sz[s]; i++){
                for(int j=0; j<=sz[t]; j++){
                    v[i+j] = min(v[i+j], dp[s][0][i] + dp[t][0][j]);
                    if(dp[t][0][j] != INF || dp[t][1][j] < 0){
                        v[i+j+1] = min(v[i+j+1], dp[s][0][i]);
                    }
                }
            }

            for(int i=0; i<sz[s]+sz[t]+2; i++){
                dp[s][0][i] = v[i];
                dp[s][0][i] = min(dp[s][0][i], INF);
            }
        }
        {
            vector<long long> v(sz[s]+sz[t]+2, INF);

            for(int i=0; i<=sz[s]; i++){
                for(int j=0; j<=sz[t]; j++){
                    v[i+j] = min(v[i+j], dp[s][0][i] + dp[t][1][j]);
                    v[i+j] = min(v[i+j], dp[s][1][i] + dp[t][0][j]);
                    v[i+j] = min(v[i+j], dp[s][1][i] + dp[t][1][j]);
                    if(dp[t][0][j] != INF || dp[t][1][j] < 0){
                        v[i+j+1] = min(v[i+j+1], dp[s][1][i]);
                    }
                }
            }

            for(int i=0; i<sz[s]+sz[t]+2; i++){
                dp[s][1][i] = v[i];
                dp[s][1][i] = min(dp[s][1][i], INF);
            }
        }
        sz[s] += sz[t];
    }
}

int main(){
    cin >> N;
    A.resize(N);
    G.resize(N);
    for(int i=0; i<N; i++) cin >> A[i];
    for(int i=0; i<N-1; i++){
        int U, V;
        cin >> U >> V;
        U--; V--;
        G[U].push_back(V);
        G[V].push_back(U);
    }
    for(int i=0; i<=N; i++)
        for(int j=0; j<2; j++)
            for(int k=0; k<=N; k++)
                dp[i][j][k] = INF;

    dfs(0, -1);

    long long ans = INF;
    for(long long i=0; i<=N; i++){
        if(dp[0][1][i] < 0){
            ans = i;
            break;
        }
    }
    for(long long i=0; i<=N; i++){
        if(dp[0][0][i] != INF){
            ans = min(ans, i);
            break;
        }
    }
    cout << ans << endl;
    return 0;
}