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

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int MAXN = 25e4;

int N;
vector<pii> adj[MAXN+10];
int A[MAXN+10];

struct Node
{
    int sz;
    int par, lc, rc;

    ll xlen, xsum, slp;
    ll lazy;
    Node(ll x, ll s)
    {
        sz=1;
        par=lc=rc=0;
        xlen=xsum=x; slp=s;
        lazy=0;
    }
    Node()
    {
        par=lc=rc=sz=0;
        xlen=xsum=slp=0;
        lazy=0;
    }
};

vector<Node> NS;
int newNode() { NS.push_back(Node()); return NS.size()-1; }
int newNode(ll x, ll s) { NS.push_back(Node(x, s)); return NS.size()-1; }

void recalc(int node)
{
    if(node==0) return;
    int l=NS[node].lc, r=NS[node].rc;

    NS[node].sz=NS[l].sz+NS[r].sz+1;
    NS[node].xsum=NS[l].xsum+NS[r].xsum+NS[node].xlen;
}

void apply2(int node, ll upd)
{
    if(node==0) return;
    NS[node].lazy+=upd;
    NS[node].slp+=upd;
}

void prop(int node)
{
    if(node==0) return;
    if(NS[node].lazy==0) return;
    apply2(NS[node].lc, NS[node].lazy);
    apply2(NS[node].rc, NS[node].lazy);
    NS[node].lazy=0;
}

void prop_anc(int x)
{
    if(NS[x].par!=0) prop_anc(NS[x].par);
    prop(x);
}

void rotate(int x)
{
    assert(x!=0 && NS[x].par!=0);
    int p=NS[x].par, q;
    if(NS[p].lc==x)
    {
        NS[p].lc=q=NS[x].rc;
        NS[x].rc=p;
    }
    else
    {
        NS[p].rc=q=NS[x].lc;
        NS[x].lc=p;
    }
    NS[x].par=NS[p].par;
    NS[p].par=x;
    if(q) NS[q].par=p;
    if(NS[x].par!=0)
    {
        if(NS[NS[x].par].lc==p) NS[NS[x].par].lc=x;
        else if(NS[NS[x].par].rc==p) NS[NS[x].par].rc=x;
    }
    recalc(p);
    recalc(x);
}

void splay(int x)
{
    if(x==0) return;
    prop_anc(x);
    while(NS[x].par)
    {
        int p=NS[x].par, q=NS[p].par;
        if(q) rotate((NS[p].lc==x)==(NS[q].lc==p) ? p : x);
        rotate(x);    
    }
}

void insert(int node, int x)
{
    if(node==0) return;
    prop(node);
    if(NS[node].slp<=NS[x].slp)
    {
        if(NS[node].rc==0)
        {
            NS[node].rc=x;
            NS[x].par=node;
        }
        else insert(NS[node].rc, x);
    }
    else
    {
        if(NS[node].lc==0)
        {
            NS[node].lc=x;
            NS[x].par=node;
        }
        else insert(NS[node].lc, x);
    }
    recalc(node);
}

void get(int node, int &root)
{
    if(node==0) return;
    prop(node);
    get(NS[node].lc, root);
    int p=newNode(NS[node].xlen, NS[node].slp);
    insert(root, p);
    splay(p);
    root=p;
    get(NS[node].rc, root);
}

int find_kth(int node, ll k)
{
    if(node==0) return 0;
    assert(0<=k && k<=NS[node].xsum);
    prop(node);
    ll p=NS[NS[node].rc].xsum;
    if(k<p) return find_kth(NS[node].rc, k);
    if(p+NS[node].xlen<k) return find_kth(NS[node].lc, k-p-NS[node].xlen);
    return node;
}

int find_right(int node)
{
    if(node==0) return 0;
    prop(node);
    if(NS[node].rc==0) return node;
    else return find_right(NS[node].rc);
}

int find_slp(int node)
{
    if(node==0) return 0;
    prop(node);
    if(NS[node].slp>0)
    {
        int ret=find_slp(NS[node].lc);
        if(ret) return ret;
        return node;
    }
    else return find_slp(NS[node].rc);
}

int split(int &root, ll k)
{
    assert(0<=k && k<=NS[root].xsum);
    int p=find_kth(root, k);
    splay(p);
    root=p;

    ll t=NS[NS[root].rc].xsum;
    if(k==t) return NS[root].rc;
    else if(k==t+NS[root].xlen)
    {
        if(NS[root].lc==0) return root;
        int q=find_right(NS[root].lc);
        splay(q);
        root=q;
        return p;
    }
    else
    {
        int q=newNode(0, 0);
        NS[q]=NS[p];
        int l=NS[p].lc, r=NS[p].rc;
        NS[q].lc=0; NS[r].par=q;
        NS[p].rc=q; NS[q].par=p;
        NS[q].xlen=k-t;
        NS[p].xlen=t+NS[p].xlen-k;
        recalc(q); recalc(p);
        return q;
    }
}

ll f(int node)
{
    if(node==0) return 0;
    prop(node);
    return NS[node].xlen*NS[node].slp + f(NS[node].lc) + f(NS[node].rc);
}

pll P[MAXN+10];
int X[MAXN+10];

void print(int node)
{
    if(node==0) return;
    prop(node);
    print(NS[node].rc);
    printf("SLP %lld / XLEN %lld / XSUM %lld\n", NS[node].slp, NS[node].xlen, NS[node].xsum);
    print(NS[node].lc);
}

void dfs(int now, int bef, int p)
{
    X[now]=0;
    P[now]={0, 0};
    for(auto [nxt, w] : adj[now])
    {
        if(nxt==bef) continue;
        dfs(nxt, now, w);
        if(NS[X[now]].sz<NS[X[nxt]].sz)
        {
            swap(P[now], P[nxt]);
            swap(X[now], X[nxt]);
        }
        P[now].first+=P[nxt].first; P[now].second+=P[nxt].second;
        get(X[nxt], X[now]);
    }

    // printf("\n");
    // printf("AFTER MINKOWSKI %d\n", now);
    // printf("NODE %d : X %lld / Y %lld\n", now, P[now].first, P[now].second);
    // print(X[now]);
    // printf("\n");

    P[now].first+=A[now];
    P[now].second+=abs(P[now].first)*p;
    if(P[now].first<=0) apply2(X[now], -p);
    else if(P[now].first<=NS[X[now]].xsum)
    {
        int t=split(X[now], P[now].first);
        prop_anc(t);
        apply2(t, p+p);
        apply2(X[now], -p);
    }
    else
    {
        int t=newNode(P[now].first-NS[X[now]].xsum, 0);
        insert(X[now], t);
        splay(t);
        X[now]=t;
        apply2(X[now], p);
    }
    int a=find_slp(X[now]);
    splay(a);
    X[now]=a;
    NS[NS[a].lc].par=0;
    NS[a].lc=0;
    recalc(X[now]);

    // printf("NODE %d : X %lld / Y %lld\n", now, P[now].first, P[now].second);
    // print(X[now]);
}

int main()
{
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    
    cin >> N;
    for(int i=1; i<N; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }
    for(int i=1; i<=N; i++)
    {
        int a, b;
        cin >> a >> b;
        A[i]=a-b;
    }

    newNode(); // NIL;
    dfs(1, 1, 0);

    int t=split(X[1], min(NS[X[1]].xsum, P[1].first));

    // printf("FINAL %d : X %lld / Y %lld\n", 1, P[1].first, P[1].second);
    // print(b);
    cout << P[1].second-f(t) << "\n";
}