/*
  Author: LIUIR
  Created: 2024.11.15  11:32:44
  Last Modified: 2024.11.15  11:52:37
*/
#include <bits/stdc++.h>

using namespace std;
using ll = long long;

const int N = 2.5e5 + 5;
const int M = 1e6 + 5;
const ll INF = 1e12;

int n, rtS[N], rtT[N];
ll ans, a[N], dis[N];
vector<int> edge[N];
vector<ll> val[N];

class Heap{
    private:
        int cur = 0;
        struct Node{
            int ls, rs, dist;
            ll val;
            bool operator < (const Node& rhs){return val < rhs.val;}
        }heap[M << 2];
        queue<int> q;
    public:
        Heap(){heap[0].dist = -1;}
        int New(ll val)
        {
            int now;
            if (q.empty())
                now = ++cur;
            else
                now = q.front(), q.pop();
            heap[now] = Node{0, 0, 0, val};
            return now;
        }
        int Merge(int u, int v)
        {
            if (!u || !v)
                return u | v;
            if (heap[u].val > heap[v].val)
                swap(u, v);
            heap[u].rs = Merge(heap[u].rs, v);
            if (heap[heap[u].ls].dist < heap[heap[u].rs].dist)
                swap(heap[u].ls, heap[u].rs);
            heap[u].dist = heap[heap[u].rs].dist + 1;
            return u;
        }
        void Delete(int& rt)
        {
            q.push(rt);
            rt = Merge(heap[rt].ls, heap[rt].rs);
        }
        friend void Work(int);
}heap;

void Work(int);
void Dfs(int, int);

signed main()
{
    scanf("%d", &n);
    for (int i = 1, u, v, w; i < n; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        edge[u].push_back(v);
        edge[v].push_back(u);
        val[u].push_back(w);
        val[v].push_back(w);
    }
    for (int i = 1, x, y; i <= n; i++)
        scanf("%d%d", &x, &y), a[i] = x - y;
    Dfs(1, 0);
    for (int i = 1; i <= n; i++)if (a[i] < 0)
        ans += -a[i] * INF;
    printf("%lld\n", ans);
    return 0;
}

void Work(int u)
{
    while(rtS[u] && rtT[u] && heap.heap[rtS[u]].val + heap.heap[rtT[u]].val - 2ll * dis[u] < 0)
    {
        ll s = heap.heap[rtS[u]].val, t = heap.heap[rtT[u]].val;
        ans += s + t - 2ll * dis[u];
        heap.Delete(rtS[u]), heap.Delete(rtT[u]);
        rtS[u] = heap.Merge(rtS[u], heap.New(2ll * dis[u] - t));
        rtT[u] = heap.Merge(rtT[u], heap.New(2ll * dis[u] - s));
    }
}
void Dfs(int u, int fa)
{
    if (a[u] > 0)
    {
        for (int i = 1; i <= a[u]; i++)
            rtS[u] = heap.Merge(rtS[u], heap.New(dis[u]));
    }
    else
    {
        for (int i = 1; i <= -a[u]; i++)
            rtT[u] = heap.Merge(rtT[u], heap.New(dis[u] - INF));
    }
    for (int i = 0; i < edge[u].size(); i++)
    {
        int v = edge[u][i];
        if (v == fa)
            continue;
        dis[v] = dis[u] + val[u][i];
        Dfs(v, u);
        rtS[u] = heap.Merge(rtS[u], rtS[v]);
        rtT[u] = heap.Merge(rtT[u], rtT[v]);
    }
    Work(u);
}