#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 LL;
typedef pair<int, int> pii;
const int MAXN = 2.5e5 + 5;

template<typename T>
void write(T x) {
    if (x >= 10)
        write(x / 10);

    cout << (char)(x % 10 + '0');
}

mt19937 rnd((unsigned long long)new char ^time(0));

namespace Treap {
struct Node {
    Node *ls, *rs;
    int fix, len, sumlen;
    LL val, tag;
    Node(void) {}
    Node(int _len, LL _val, Node *emp): ls(emp), rs(emp), fix(rnd()), len(_len), sumlen(len), val(_val), tag(0) {}
} *emp, pool[MAXN * 4], *curpool = pool;
void init(void) {
    emp = curpool++;
    *emp = Node(0, 0, emp);
}
Node *new_Node(int _len, LL _val) {
    Node *u = curpool++;
    *u = Node(_len, _val, emp);
    return u;
}

void push_up(Node *u) {
    u -> sumlen = u -> ls -> sumlen + u -> rs -> sumlen + u -> len;
}
void upd(Node *u, LL k) {
    if (u != emp)
        u -> val += k, u -> tag += k;
}
void push_down(Node *u) {
    if (u -> tag) {
        upd(u -> ls, u -> tag);
        upd(u -> rs, u -> tag);
        u -> tag = 0;
    }
}

void split_len(Node *u, Node *&l, Node *&r, int k) { // len <= k
    if (u == emp) {
        l = r = emp;
        return;
    }

    push_down(u);

    if (u -> ls -> sumlen + u -> len <= k) {
        l = u;
        split_len(u -> rs, l -> rs, r, k - u -> ls -> sumlen - u -> len);
        push_up(l);
    } else {
        r = u;
        split_len(u -> ls, l, r -> ls, k);
        push_up(r);
    }
}
void split_val(Node *u, Node *&l, Node *&r, LL k) { // val <= k
    if (u == emp) {
        l = r = emp;
        return;
    }

    push_down(u);

    if (u -> val <= k) {
        l = u;
        split_val(u -> rs, l -> rs, r, k);
        push_up(l);
    } else {
        r = u;
        split_val(u -> ls, l, r -> ls, k);
        push_up(r);
    }
}
void split_lef(Node *u, Node *&l, Node *&r) {
    if (u == emp) {
        l = r = emp;
        return;
    }

    push_down(u);

    if (u -> ls == emp) {
        l = u;
        r = u -> rs;
        l -> rs = emp;
        push_up(l);
    } else {
        r = u;
        split_lef(u -> ls, l, r -> ls);
        push_up(r);
    }
}
void merge(Node *&u, Node *l, Node *r) {
    if (l == emp) {
        u = r;
        return;
    }

    if (r == emp) {
        u = l;
        return;
    }

    push_down(l);
    push_down(r);

    if (l -> fix > r -> fix) {
        u = l;
        merge(u -> rs, l -> rs, r);
    } else {
        u = r;
        merge(u -> ls, l, r -> ls);
    }

    push_up(u);
}
void join(Node *&u, Node *v) {
    if (v == emp)
        return;

    if (u == emp) {
        u = v;
        return;
    }

    if (u -> fix < v -> fix)
        swap(u, v);

    push_down(u);
    push_down(v);
    Node *l, *r;
    split_val(v, l, r, u -> val);
    join(u -> ls, l);
    join(u -> rs, r);
    push_up(u);
}
pair<Node *, Node *> cut(Node *rt, int k) {
    Node *l, *mid, *r;
    split_len(rt, l, r, k);

    if (l -> sumlen == k)
        return {l, r};

    split_lef(r, mid, r);

    int delta = k - l -> sumlen;

    merge(l, l, new_Node(delta, mid -> val));

    mid -> len -= delta;

    push_up(mid);

    merge(r, mid, r);

    return {l, r};
}
LL getsum(Node *rt) {
    if (rt == emp)
        return 0;

    push_down(rt);
    return rt -> val * rt -> len + getsum(rt -> ls) + getsum(rt -> rs);
}
} using namespace Treap;

int a[MAXN], b[MAXN];
vector<pii> g[MAXN];

int sum[MAXN];
void dfs_sum(int u, int fa) {
    sum[u] = a[u] - b[u];

    for (auto it : g[u]) {
        int v = it.first;

        if (v == fa)
            continue;

        dfs_sum(v, u);
        sum[u] += sum[v];
    }
}

int d;

Node *f[MAXN];
LL f0[MAXN];

void dfs_f(int u, int fa) {
    f[u] = new_Node(d, 0);
    f0[u] = 0;

    for (auto it : g[u]) {
        int v = it.first, w = it.second;

        if (v == fa)
            continue;

        dfs_f(v, u);

        Node *l, *r;
        tie(l, r) = cut(f[v], max(0, min(d, sum[v])));

        f0[v] += (ll)abs(sum[v]) * w;
        upd(l, -w);
        upd(r, w);

        join(f[u], l);
        join(f[u], r);

        f[u] = cut(f[u], d).first;
        f0[u] += f0[v];
    }
}

int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;

    for (int i = 1; i < n; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        g[u].emplace_back(v, w);
        g[v].emplace_back(u, w);
    }

    for (int i = 1; i <= n; ++i)
        cin >> a[i] >> b[i];

    Treap::init();

    dfs_sum(1, 0);
    d = sum[1];
    dfs_f(1, 0);

    LL ans = f0[1] + getsum(f[1]);

    write(ans);
    return 0;
}