/**
 * @author n685
 * @date 2024-12-30 11:27:31
 */
#include "bits/stdc++.h"

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbg_proj(...) 420
#define dbg_rproj(...) 420420
void nline() {}
void bar() {}
void start_clock() {}
void end_clock() {}
#endif

namespace rs = std::ranges;
namespace rv = std::views;

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;

struct Tree {
  static constexpr int LG = 20;
  int n;
  const std::vector<std::vector<int>>& adj;
  std::vector<int> p, d, sub;
  std::vector<std::vector<int>> lift;
  std::vector<int> tl, tr;
  void dfs(int node, int par, int& cnt) {
    tl[node] = cnt++;
    p[node] = par;
    for (int i : adj[node]) {
      if (i == par) {
        continue;
      }
      d[i] = d[node] + 1;
      dfs(i, node, cnt);
      sub[node] += sub[i];
    }
    tr[node] = cnt - 1;
  }
  explicit Tree(const std::vector<std::vector<int>>& adj_)
      : n(static_cast<int>(adj_.size())),
        adj(adj_),
        p(n, -1),
        d(n),
        sub(n, 1),
        lift(LG, std::vector<int>(n, -1)),
        tl(n),
        tr(n) {
    int cnt = 0;
    dfs(0, -1, cnt);
    lift[0] = p;
    for (int i = 1; i < LG; ++i) {
      for (int j = 0; j < n; ++j) {
        if (lift[i - 1][j] != -1) {
          lift[i][j] = lift[i - 1][lift[i - 1][j]];
        }
      }
    }
  }
  int up(int u, int dist) const {
    if (dist < 0) {
      return -1;
    }
    if (d[u] < dist) {
      return -1;
    }
    for (int i = 0; i < LG; ++i) {
      if (((1 << i) & dist) != 0) {
        u = lift[i][u];
      }
    }
    return u;
  }
  // is v an ancestor of u?
  bool ancestor(int u, int v) const { return tl[u] <= tl[v] && tl[v] <= tr[u]; }

  int lca(int u, int v) const {
    if (d[u] < d[v]) {
      std::swap(u, v);
    }
    if (ancestor(v, u)) {
      return v;
    }
    for (int i = LG - 1; i >= 0; --i) {
      if (d[u] >= (1 << i) && !ancestor(lift[i][u], v)) {
        u = lift[i][u];
      }
    }
    return p[u];
  }

  int dist(int u, int v) const { return d[u] + d[v] - 2 * d[lca(u, v)]; }
};

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

  std::vector<int> p(n);
  for (int& v : p) {
    std::cin >> v;
    --v;
  }
  std::vector<std::pair<int, int>> edges;
  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);
    edges.emplace_back(u, v);
  }
  Tree tr(adj);

  auto cost = [&](int u, int v) {
    int d = tr.dist(u, v);
    return d * d;
  };

  std::vector<std::vector<int>> ans;
  while (true) {
    std::vector<std::pair<int, int>> li;
    std::vector<int> fl;
    std::vector<bool> vis(n);
    for (int i = 0; i < n - 1; ++i) {
      auto [u, v] = edges[i];
      li.emplace_back(
        (cost(u, p[v]) + cost(v, p[u])) - (cost(u, p[u]) + cost(v, p[v])),
        i
      );
    }
    rs::sort(li);
    for (auto [c, i] : li) {
      if (c > 0) {
        break;
      }
      auto [u, v] = edges[i];
      if (vis[u] || vis[v]) {
        continue;
      }
      vis[u] = true;
      vis[v] = true;
      fl.push_back(i);
      std::swap(p[u], p[v]);
    }
    if (fl.empty()) {
      break;
    }
    ans.push_back(fl);
  }
  std::cout << ans.size() << '\n';
  for (const std::vector<int>& v : ans) {
    std::cout << v.size();
    for (int i : v) {
      std::cout << ' ' << i + 1;
    }
    std::cout << '\n';
  }
}

int main() {
#ifndef LOCAL
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
#endif

  int t;
  std::cin >> t;
  for (int i = 0; i < t; ++i) {
    dbg(i + 1);
    solve();
    bar();
  }
}