#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct DSU {
    vector<int> fa;
    DSU(int n) : fa(n + 1) {
        for (int i = 1; i <= n; i++) {
            fa[i] = i;
        }
    }
    int getfa(int v) { return (fa[v] == v) ? v : (fa[v] = getfa(fa[v])); }
    void merge(int u, int v) { fa[getfa(u)] = getfa(v); }
};

struct Tree {
    int n;
    vector<vector<int>> e;
    vector<pair<ll, ll>> p;
    vector<int> fa;
    DSU dsu;
    Tree(int _n) : n(_n), e(n + 1), p(n + 1), fa(n + 1), dsu(n + 1) {
        for (int i = 2; i <= n; i++) {
            cin >> p[i].first >> p[i].second;
        }
        for (int i = 2; i <= n; i++) {
            int u, v;
            cin >> u >> v;
            e[u].emplace_back(v);
            e[v].emplace_back(u);
        }
        getfa(1, 1);
    }
    void getfa(int v, int f) {
        fa[v] = f;
        for (auto u : e[v]) {
            if (u != f) {
                getfa(u, v);
            }
        }
    }
    ll solve() {
        struct Pa {
            ll a, b, id;
			int t;
            bool operator<(const Pa& y) const { return a > y.a; }
        };
        struct Pb {
            ll a, b, id;
			int t;
            bool operator<(const Pb& y) const { return b < y.b; }
        };
        priority_queue<Pa> sa;
        priority_queue<Pb> sb;
        auto insert = [&](int i, int t) {
            if (i > 1) {
                if (p[i].first <= p[i].second) {
                    sa.push({p[i].first, p[i].second, i, t});
                } else {
                    sb.push({p[i].first, p[i].second, i, t});
                }
            }
        };
        for (int i = 2; i <= n; i++) {
            insert(i, 0);
        }
		vector<int> tag(n + 1);
        for (int i = 2; i <= n; i++) {
            if (sa.empty()) {
                auto [_a, _b, id, _t] = sb.top();
				sb.pop();
                int f = dsu.getfa(fa[id]);
                auto [a, b] = p[f];
                p[f].first = max(a, a - b + _a);
                p[f].second = -a + b - _a + _b + p[f].first;
                insert(f, ++tag[f]);
                dsu.merge(id, f);
            } else {
                auto [_a, _b, id, _t] = sa.top();
				sa.pop();
                int f = dsu.getfa(fa[id]);
                auto [a, b] = p[f];
                p[f].first = max(a, a - b + _a);
                p[f].second = -a + b - _a + _b + p[f].first;
                insert(f, ++tag[f]);
                dsu.merge(id, f);
            }
			while (!sa.empty() && sa.top().t < tag[sa.top().id]) {
				sa.pop();
			}
			while (!sb.empty() && sb.top().t < tag[sb.top().id]) {
				sb.pop();
			}
        }
        return p[1].first;
    }
};

void solve() {
    int n;
    cin >> n;
    Tree tr(n);
    cout << tr.solve() << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int T;
    cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}