#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <cmath>
#include <map>
#include <vector>
#include <iterator>
#include <cstring>
#include <string>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define INF 0x7fffffff
#define ll long long
#define N 6010

struct Edge
{
    int to,next;
}edge[N<<1];
int head[N],tot;
int n;
int f[N];
int val[N];
int vis[N];
int dp[N][2];

template <class T>
inline bool input(T &ret)
{
    char c; int sgn;
    if(c=getchar(),c==EOF) return 0;
    while(c!=‘-‘&&(c<‘0‘||c>‘9‘)) c=getchar();
    sgn=(c==‘-‘)?-1:1;
    ret=(c==‘-‘)?0:(c-‘0‘);
    while(c=getchar(),c>=‘0‘&&c<=‘9‘) ret=ret*10+(c-‘0‘);
    ret*=sgn;
    return 1;
}

inline void out(int x)
{
    if(x>9) out(x/10);
    putchar(x%10+‘0‘);
}

void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
    memset(f,0,sizeof(f));
    memset(dp,0,sizeof(dp));
    memset(vis,0,sizeof(vis));
}

void add(int x,int y)
{
    edge[tot].to=y;
    edge[tot].next=head[x];
    head[x]=tot++;
}

void dfs(int u)
{
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(!vis[v])
        {
            vis[v]=1;
            dfs(v);
            dp[u][1]+=dp[v][0];
            dp[u][0]+=max(dp[v][0],dp[v][1]);
        }
    }
    dp[u][1]+=val[u];
}

int main()
{
    int i;
    while(input(n))
    {
        init();
        for(i=1;i<=n;i++)
        {
            input(val[i]);
        }
        int a,b;
        while(1)
        {
            input(a);
            input(b);
            if(a+b==0) break;
            f[a]=b;
            add(b,a);
        }
        int root=1;
        while(f[root])
        {
            root=f[root];
        }
        vis[root]=1;
        dfs(root);
        out(max(dp[root][0],dp[root][1]));
        putchar(‘\n‘);
    }
    return 0;
}