#include <bits/stdc++.h>

using LL = long long;

constexpr int N = 100005;

struct Val { 
    LL x, y; 
    friend bool operator<(Val a, Val b) {
        if (a.y >= 0 && b.y < 0) return 1;
        if (a.y < 0 && b.y >= 0) return 0;
        if (a.y < 0) return std::max(a.x, b.x - a.y) < std::max(b.x, a.x - b.y);
        else return a.x < b.x;
    }
};

int n;
Val val[N];
int fa[N], par[N], g[N];
std::vector<int> tree[N];

void predfs(int u, int p) {
    fa[u] = p;
    for (int v : tree[u]) {
        if (v == p) continue;
        predfs(v, u);
    }
}
int find_par(int x) { return par[x] == x ? x : par[x] = find_par(par[x]); }

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cin >> n;
    for (int i = 2; i <= n; i++) {
        int a, b;
        std::cin >> a >> b;
        val[i] = {a, b - a};
    }
    for (int i = 1; i < n; i++) {
        int x, y;
        std::cin >> x >> y;
        tree[x].push_back(y);
        tree[y].push_back(x);
    }
    predfs(1, 0);
    std::priority_queue<std::tuple<Val, int, int>, std::vector<std::tuple<Val, int, int>>, std::greater<std::tuple<Val, int, int>>> que;
    for (int i = 2; i <= n; i++) que.push({val[i], i, g[i]});
    std::iota(par + 1, par + n + 1, 1);
    while (que.size()) {
        auto [v, x, t] = que.top();
        que.pop();
        if (x == 1) continue;
        if (t != g[x]) continue;
        int p = find_par(fa[x]);
        val[p].x = std::max(val[p].x, v.x - val[p].y);
        val[p].y += v.y;
        que.push({val[p], p, ++g[p]});
        par[x] = p;
    }
    printf("%lld\n", val[1].x);
    return 0;
}