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

using ll = long long;
#define int ll
using pii = pair<ll, ll>;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()

const int INF = 2e9, maxN = 2e5+100, M = 998244353, LOG = 16;
const ll LINF = 1e18;

struct CHT { //convex hull trick
    struct Line {
        ll slope, yIntercept;
 
        Line (ll slope, ll intercept) : slope(slope), yIntercept(intercept) { }
        ll val(ll x) {
            return x * slope + yIntercept;
        }
        ll intersect(Line y) {
            return (y.yIntercept - yIntercept + slope - y.slope - 1) 
                                                / (slope - y.slope);
        }
    };
 
    vector<pair<Line, ll>> v;
    int p = 0;
 
    void insert(ll slope, ll yIntercept) {
        Line newLine(slope, yIntercept);
 
        if(v.empty()) {
            v.emplace_back(newLine, 0);
            return;
        }
        while(v.size() > 1 and v.back().second >= newLine.intersect(v.back().first))
            v.pop_back();
 
        v.emplace_back(newLine, v.back().first.intersect(newLine));
    }
 
    ll query(ll x) { //IF QUERIES ARE GIVEN IN SORTED ORDER
        while(p+1 < v.size() and v[p+1].second <= x)
            p++;
        if(p >= v.size()) p = v.size() - 1;
        return v[p].first.val(x);
    }
};


int n, blocked[maxN], tree_sz[maxN], A[maxN], par[maxN];
ll ans[maxN];
vector<pii> adj[maxN];

void compute_subtrees(int s, int p) { //just for subtree sizes
    tree_sz[s] = 1;
    for(auto [u, w] : adj[s]) if(u != p and !blocked[u]) {
        compute_subtrees(u, s);
        tree_sz[s] += tree_sz[u];
    }
}


vector<pii> bfs(int u) { //returns {node_id, distance from current centroid}
    vector<pii> nodes {{u, 0}};
    queue<pii> q;
    q.push({u, 0});
    par[u]= 0;

    while(q.size()) {
        auto [s, c] = q.front(); q.pop();
        
        for(auto [v, w] : adj[s]) if(!blocked[v] and v != par[s]) {
            nodes.push_back({v, w + c});
            par[v] = s;
            q.push({v, w + c});
        }
    }
    return nodes;
}

void conquer(int u) {
    compute_subtrees(u, 0);

    int p = 0, N = tree_sz[u];
    while(true) {
        bool centroid = true;
        for(auto [v, w] : adj[u]) {
            if(!blocked[v] and v != p and tree_sz[v] * 2 > N) {
                p = u;
                u = v;
                centroid = false;
                break;
            }
        }
        if(centroid) break;
    }

    CHT cht;
    auto nodes = bfs(u);

    // Sort by their slopes in descending order
    sort(all(nodes), [&] (pii& i, pii& j) { 
        if(A[i.first] != A[j.first]) return A[i.first] > A[j.first];
        return i.second > j.second;
    });
    
    //We cant deal with equal slopes, so we erase all sames except the one which has 
    // the minimum y coefficent value
    for(int i = 0; i < nodes.size(); i++) {
        while(i < nodes.size()-1 and A[nodes[i].first] == A[nodes[i+1].first])
            ++i;
        cht.insert(A[nodes[i].first], nodes[i].second);
    }

    //queries must be asked in ascending order by their slopes 
    //(because of my CHT implementation)
    reverse(all(nodes));
    
    for(auto [x, c] : nodes)  ans[x] = min(ans[x], cht.query(A[x]) + c);

    blocked[u] = true;
    //the dividing part
    for(auto [v, w] : adj[u]) if(!blocked[v]) conquer(v);
}

signed main () {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n;
    
    for(int i = 1; i <= n; i++) {
        cin >> A[i];
        ans[i] = A[i] * A[i];
    }

    for(int i = 1; i < n; i++) {
        int x, y, w;
        cin >> x >> y >> w;
        adj[x].push_back({y, w});
        adj[y].push_back({x, w});
    }
    conquer(1);

    ll result = 0;
    for(int i = 1; i <= n; i++) {
        result += ans[i];
    }
    cout << result;
}