def main():
    import sys
    sys.setrecursionlimit(1 << 25)
    N = int(sys.stdin.readline())
    a = list(map(int, sys.stdin.readline().split()))
    sum_a = sum(a)
    b = list(map(int, sys.stdin.readline().split()))
    adj = [[] for _ in range(N+1)]
    for _ in range(N-1):
        u, v = map(int, sys.stdin.readline().split())
        adj[u].append(v)
        adj[v].append(u)
    
    # Build children list with parent pointers, rooted at 1.
    root = 1
    parent = [0]*(N+1)
    children = [[] for _ in range(N+1)]
    stack = [(root, None)]
    while stack:
        u, p = stack.pop()
        parent[u] = p
        for v in adj[u]:
            if v != p:
                children[u].append(v)
                stack.append((v, u))
    
    # Generate post order traversal
    post_order = []
    stack = [(root, False)]
    while stack:
        node, processed = stack.pop()
        if processed:
            post_order.append(node)
        else:
            stack.append( (node, True) )
            # Push children in reverse order to process in original order.
            for child in reversed(children[node]):
                stack.append( (child, False) )
    
    # Initialize dp arrays
    dp0 = [0]*(N+1)
    dp1 = [0]*(N+1)
    
    for u in post_order:
        sum_dp0 = 0
        sum_dp1 = 0
        for child in children[u]:
            sum_dp0 += max(dp0[child], dp1[child])
            option = max( dp0[child], dp1[child] + (b[u-1] + b[child-1]) )
            sum_dp1 += option
        dp0[u] = sum_dp0
        dp1[u] = sum_dp1 - a[u-1]
    
    max_val = max(dp0[root], dp1[root])
    print( sum_a + max_val )

if __name__ == '__main__':
    main()