#include <bits/stdc++.h>

using i64 = long long;

template <typename T, typename Cmp = std::less<T>>
struct RMQ {
    const Cmp cmp;
    int n;
    std::vector<std::vector<T>> a;
    RMQ() = default;
    RMQ(const std::vector<T> &v) : cmp{} {
        init(v);
    }
    RMQ(const std::vector<T> &v, const Cmp &cmp_) : cmp{cmp_} {
        init(v);
    }
    void init(const std::vector<T> &ini) {
        n = int(ini.size());
        int lg = std::__lg(n);
        a.assign(lg + 1, std::vector<T>(n));
        a[0] = ini;
        for (int i = 0; i < lg; ++i) {
            for (int j = 0; j <= n - (2 << i); ++j) {
                a[i + 1][j] = std::min(a[i][j], a[i][j + (1 << i)], cmp);
            }
        }
    }
    T operator()(int l, int r) const {
        int k = std::__lg(r - l);
        return std::min(a[k][l], a[k][r - (1 << k)], cmp);
    }
};

void solve() {
    int n;
    std::cin >> n;

    std::vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> a[i];
    }

    std::vector<std::vector<int>> adj(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        std::cin >> u >> v;
        --u, --v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    std::vector<int> fa(n, -1), dep(n), dfn(n);
    int cur = 0;
    std::vector<std::vector<int>> pos(n);
    auto dfs = [&](auto self, int u) -> void {
        dfn[u] = cur++;
        pos[dep[u]].push_back(u);
        for (auto v : adj[u]) {
            if (v == fa[u]) {
                continue;
            }
            fa[v] = u;
            dep[v] = dep[u] + 1;
            self(self, v);
        }
    };
    dfs(dfs, 0);

    fa[0] = 0;
    auto cmp = [&](int x, int y) {
        return dfn[x] < dfn[y];
    };
    RMQ<int, decltype(cmp)> frmq(fa, cmp);
    auto lca = [&](int u, int v) {
        if (u == v) {
            return u;
        }
        u = dfn[u];
        v = dfn[v];
        if (u > v) {
            std::swap(u, v);
        }
        return frmq(u + 1, v + 1);
    };

    RMQ rmq(a);

    i64 ans = 0;
    std::vector<std::vector<int>> e(n);
    std::vector<i64> w(n), f(n);
    for (int x = 0; x < n; ++x) {
        // std::cerr << "Solve" << x << ":\n";
        auto s = pos[x];
        if (s.empty()) {
            continue;
        }
        s.push_back(0);
        std::sort(s.begin(), s.end(), cmp);
        s.erase(std::unique(s.begin(), s.end()), s.end());
        for (int i = int(s.size()) - 1; i > 0; --i) {
            s.push_back(lca(s[i], s[i - 1]));
        }
        std::sort(s.begin(), s.end(), cmp);
        s.erase(std::unique(s.begin(), s.end()), s.end());

        for (int i = 1; i < int(s.size()); ++i) {
            int u = s[i], f = lca(s[i], s[i - 1]);
            e[f].push_back(u);
            w[u] = rmq(x - dep[u], x - dep[f]);
            // std::cerr << f << "->" << u << " " << w[u] << "\n";
        }
        w[0] = a[x];

        auto dfs = [&](auto self, int u) -> void {
            for (auto v : e[u]) {
                self(self, v);
                f[u] += f[v];
            }
            if (dep[u] == x) {
                f[u] = 1e18;
            }
            f[u] = std::min(f[u], w[u]);
            // std::cerr << u << ": " << f[u] << "\n";
        };
        dfs(dfs, 0);
        ans += f[0];
        // std::cerr << f[0] << "\n";

        for (auto u : s) {
            e[u].clear();
            f[u] = 0;
        }
    }

    std::cout << ans << "\n";
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}