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

#define ll long long

const ll INF = (ll)4e18;

struct Dinic {
    struct Edge {
        int v;
        ll cap;
        int rev;
    };

    int n;
    vector<vector<Edge>> g;
    vector<int> level, cur;

    Dinic(int n) : n(n) {
        g.resize(n + 1);
        level.resize(n + 1);
        cur.resize(n + 1);
    }

    void addEdge(int u, int v, ll c) {
        Edge a = {v, c, (int)g[v].size()};
        Edge b = {u, 0, (int)g[u].size()};

        g[u].push_back(a);
        g[v].push_back(b);
    }

    bool bfs(int s, int t) {
        fill(level.begin(), level.end(), -1);

        queue<int> q;
        q.push(s);
        level[s] = 0;

        while (!q.empty()) {
            int u = q.front();
            q.pop();

            for (auto &e : g[u]) {
                if (e.cap > 0 && level[e.v] == -1) {
                    level[e.v] = level[u] + 1;
                    q.push(e.v);
                }
            }
        }

        return level[t] != -1;
    }

    ll dfs(int u, int t, ll pushed) {
        if (u == t || pushed == 0)
            return pushed;

        for (int &i = cur[u]; i < (int)g[u].size(); i++) {
            Edge &e = g[u][i];

            if (e.cap <= 0 || level[e.v] != level[u] + 1)
                continue;

            ll tr = dfs(e.v, t, min(pushed, e.cap));

            if (tr == 0)
                continue;

            e.cap -= tr;
            g[e.v][e.rev].cap += tr;

            return tr;
        }

        return 0;
    }

    ll maxflow(int s, int t) {
        ll ans = 0;

        while (bfs(s, t)) {
            fill(cur.begin(), cur.end(), 0);

            while (ll pushed = dfs(s, t, INF))
                ans += pushed;
        }

        return ans;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, k;
    cin >> n >> k;

    vector<ll> a(n + 1);

    for (int i = 1; i <= n; i++)
        cin >> a[i];

    vector<vector<int>> adj(n + 1);

    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;

        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    struct Query {
        int u, v;
        ll c;
    };

    vector<Query> q(k + 1);

    for (int i = 1; i <= k; i++)
        cin >> q[i].u >> q[i].v >> q[i].c;

    // Binary lifting

    int LOG = 1;
    while ((1 << LOG) <= n)
        LOG++;

    vector<vector<int>> up(n + 1, vector<int>(LOG));
    vector<int> depth(n + 1);

    // Iterative DFS

    vector<int> order;
    order.reserve(n);

    order.push_back(1);
    up[1][0] = 1;

    for (int i = 0; i < (int)order.size(); i++) {
        int u = order[i];

        for (int v : adj[u]) {
            if (v == up[u][0])
                continue;

            up[v][0] = u;
            depth[v] = depth[u] + 1;

            order.push_back(v);
        }
    }

    for (int j = 1; j < LOG; j++) {
        for (int u = 1; u <= n; u++) {
            up[u][j] = up[up[u][j - 1]][j - 1];
        }
    }

    auto lca = [&](int u, int v) {
        if (depth[u] < depth[v])
            swap(u, v);

        int d = depth[u] - depth[v];

        for (int i = 0; i < LOG; i++) {
            if (d >> i & 1)
                u = up[u][i];
        }

        if (u == v)
            return u;

        for (int i = LOG - 1; i >= 0; i--) {
            if (up[u][i] != up[v][i]) {
                u = up[u][i];
                v = up[v][i];
            }
        }

        return up[u][0];
    };

    // Tao node phu (u, i)

    vector<vector<int>> id(n + 1, vector<int>(LOG));

    int cnt = n;

    for (int u = 1; u <= n; u++) {
        id[u][0] = ++cnt;
    }

    for (int i = 1; i < LOG; i++) {
        for (int u = 1; u <= n; u++) {
            if (depth[u] + 1 < (1 << i))
                continue;

            id[u][i] = ++cnt;
        }
    }

    // Node ngay

    vector<int> day(k + 1);

    for (int i = 1; i <= k; i++)
        day[i] = ++cnt;

    int S = ++cnt;
    int T = ++cnt;

    Dinic dinic(cnt);

    // Original nodes -> T

    for (int u = 1; u <= n; u++)
        dinic.addEdge(u, T, a[u]);

    // Auxiliary nodes

    for (int u = 1; u <= n; u++) {
        dinic.addEdge(id[u][0], u, INF);
    }

    for (int i = 1; i < LOG; i++) {
        for (int u = 1; u <= n; u++) {
            if (!id[u][i])
                continue;

            int mid = up[u][i - 1];

            dinic.addEdge(id[u][i], id[u][i - 1], INF);
            dinic.addEdge(id[u][i], id[mid][i - 1], INF);
        }
    }

    // Phan ra doan di len tu u, gom len dinh LCA neu can

    auto addPath = [&](int d, int u, int len) {
        for (int i = LOG - 1; i >= 0; i--) {
            if (len >> i & 1) {
                dinic.addEdge(day[d], id[u][i], INF);

                u = up[u][i];
            }
        }
    };

    // Source -> day -> auxiliary nodes

    for (int i = 1; i <= k; i++) {
        int u = q[i].u;
        int v = q[i].v;
        ll c = q[i].c;

        dinic.addEdge(S, day[i], c);

        int w = lca(u, v);

        // u -> LCA (co lay LCA)
        addPath(i, u, depth[u] - depth[w] + 1);

        // v -> LCA (khong lay LCA)
        addPath(i, v, depth[v] - depth[w]);
    }

    cout << dinic.maxflow(S, T) << '\n';

    return 0;
}