/////////////////////////   _LeMur_
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cassert>
#include <bitset>
#include <cstdio>
#include <vector>
#include <string>
#include <ctime>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <list>
#include <map>
#include <set>
 
using namespace std;
 
const int N = 100005;
const int inf = 1000 * 1000 * 1000;
const int mod = 998244353;
 
int n;
int a[N];
 
vector < pair<int,int> > g[N];
bool used[N];
 
int order[N] , nn;
 
long long dp[N] , fin[N];
long long DP[N] , mn[N];
 
void rec(int v,int p){
    ++nn;
    order[v] = 1;
    dp[v] = fin[v] = 0;
    DP[v] = mn[v] = 0;
    for(int i=0;i<(int)g[v].size();i++){
        int to = g[v][i].first;
        if(to == p || used[to])continue;
        rec(to , v);
        order[v] += order[to];
    }
}
 
int mnn , gag;
 
vector < long long > G;
 
void dfs(int v,int p){
    int mx = nn - order[v];
    for(int i=0;i<(int)g[v].size();i++){
        int to = g[v][i].first;
        int len = g[v][i].second;
        if(to == p || used[to])continue;
        dfs(to , v);
        mx = max(mx , order[to]);
    }
    if(mx < mnn){
        mnn = mx;
        gag = v;
    }
}
 
void made(int v,int p){
    order[v] = 1;
    for(int i=0;i<(int)g[v].size();i++){
        int to = g[v][i].first;
        int len = g[v][i].second;
        if(to == p || used[to])continue;
        ///
        fin[to] = fin[v] + a[v] - len;
        dp[to] = dp[v];
        if(fin[to] < 0){
            dp[to] -= fin[to];
            fin[to] = 0;
        }
        ///
        int delta = a[to] - len;
        DP[to] = DP[v] + delta;
        mn[to] = min(1ll * delta , mn[v] + delta);
        ///
        made(to , v);
        order[v] += order[to];
    }
    if(mn[v] >= 0){
        G.push_back(DP[v]);
    }
}
 
int findcenter(int v){
    nn = 0;
    rec(v , -1);
    mnn = inf;
    dfs(v , -1);
    made(gag , -1);
    return gag;
}
 
long long answ = 0;
map < long long,int > mp;
 
vector < long long > P;
vector <int> vert;
 
void solve(int v,int p){
    if(p != -1){
        vert.push_back(v);
        if(mn[v] >= 0){
            P.push_back(DP[v]);
        }
    }
    int id = lower_bound(G.begin() , G.end() , dp[v]) - G.begin();
    answ += (int)G.size() - id;
    if(p == -1) answ--;
    ///
    for(int i=0;i<(int)g[v].size();i++){
        int to = g[v][i].first;
        if(to == p || used[to])continue;
        solve(to , v);
        if(p == -1){
            sort(P.begin() , P.end());
            for(int j=0;j<(int)vert.size();j++){
                int gag = vert[j];
                int id = lower_bound(P.begin() , P.end() , dp[gag]) - P.begin();
                answ -= (int)P.size() - id;
            }
            P.clear();
            vert.clear();
        }
    }
}
 
void centroid(){
    queue <int> q;
    q.push(1);
    while(!q.empty()){
        int v = q.front();
        q.pop();
        v = findcenter(v);
        ///
        sort(G.begin() , G.end());
        solve(v , -1);
        G.clear();
        ///
        for(int i=0;i<(int)g[v].size();i++){
            int to = g[v][i].first;
            if(order[to] == 1 || used[to])continue;
            q.push(to);
        }
        used[v] = true;
    }
}
 
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1;i<n;i++){
        int a , b , c;
        scanf("%d%d%d",&a,&b,&c);
        g[a].push_back(make_pair(b , c));
        g[b].push_back(make_pair(a , c));
    }
    centroid();
    cout<<answ<<endl;
    return 0;
}