#include <bits/stdc++.h>

#define LOG(FMT...) fprintf(stderr, FMT)

#define fir first
#define sec second

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

ostream &operator<<(ostream &os, const pair<char, int> &unit) {
  return os << unit.first << "^" << unit.second;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int M = 1000010;

struct Node {
  ll key, lazy;
  int ls, rs, dist;
} P[M << 1];

int top;

void update(int o) {
  if (P[P[o].ls].dist < P[P[o].rs].dist) swap(P[o].ls, P[o].rs);
  P[o].dist = P[P[o].rs].dist + 1;
}

void apply(int o, ll x) {
  P[o].lazy += x;
  P[o].key += x;
}

void pushdown(int o) {
  if (P[o].lazy) {
    apply(P[o].ls, P[o].lazy);
    apply(P[o].rs, P[o].lazy);
    P[o].lazy = 0;
  }
}

int create(ll x) {
  int o = ++top;
  P[o].key = x;
  return o;
}

template<class Compare>
struct LeftistManager {
  Compare comp;

  int merge(int x, int y) {
    if (x == 0 || y == 0) return x ^ y;
    pushdown(x);
    pushdown(y);
    if (!comp(P[x].key, P[y].key)) swap(x, y);
    P[x].rs = merge(P[x].rs, y);
    update(x);
    return x;
  }
  pair<int, int> pop(int o) {
    pushdown(o);
    int x = o, y = merge(P[o].ls, P[o].rs);
    P[x].ls = P[x].rs = P[x].dist = 0;
    return make_pair(x, y);
  }
};

LeftistManager<less<ll>> le;
LeftistManager<greater<ll>> ge;

const int N = 250010;

struct Convex {
  int ls, rs, lc, k;
  ll b;

  void balance() {
    while (k > lc && rs) {
      int x;
      tie(x, rs) = le.pop(rs);
      ls = ge.merge(ls, x);
      ++lc;
    }
    while (k < lc) {
      int x;
      tie(x, ls) = ge.pop(ls);
      rs = le.merge(rs, x);
      --lc;
    }
  }
  void correct() {
    while (ls && rs && P[ls].key > P[rs].key) {
      int x, y;
      tie(x, ls) = ge.pop(ls);
      tie(y, rs) = le.pop(rs);
      ls = ge.merge(ls, y);
      rs = le.merge(rs, x);
    }
  }
  void inc() {
    ++k;
    balance();
  }
  void ins() {
    int o = create(0);
    if (ls && P[ls].key >= 0) {
      ls = ge.merge(ls, o);
      ++lc;
    } else rs = le.merge(rs, o);
    balance();
  }
  void val(ll x) {
    b += x * k;
    apply(ls, -x);
    apply(rs, x);
  }
};

int n;
vector<pair<int, int>> g[N];
bool vis[N];
int x[N], y[N];
Convex ds[N];

void dfs(int u) {
  vis[u] = true;
  for (const auto &pr : g[u])
    if (!vis[pr.first]) {
      int v, w;
      tie(v, w) = pr;
      dfs(v);
      ds[v].val(w);
      ds[u].ls = ge.merge(ds[u].ls, ds[v].ls);
      ds[u].rs = le.merge(ds[u].rs, ds[v].rs);
      ds[u].k += ds[v].k;
      ds[u].lc += ds[v].lc;
      ds[u].b += ds[v].b;
      ds[u].balance();
      ds[u].correct();
    }
  while (x[u] > y[u]) {
    --x[u];
    ds[u].ins();
  }
  while (y[u] > x[u]) {
    --y[u];
    ds[u].inc();
  }
}

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  cin >> n;
  for (int rep = 1; rep < n; ++rep) {
    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 >> x[i] >> y[i];
  dfs(1);
  int o = ds[1].ls;
  ll ans = ds[1].b;
  while (o) {
    ans += P[o].key;
    o = ge.pop(o).second;
  }
  cout << ans << '\n';

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
      -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}