#include<stdio.h>
#include<algorithm>
#include<vector>
typedef long long ll;
constexpr int N{1000};
struct edge {
    int v,next;
};
edge e[(N<<1)+5];
int en,last[N+5];
inline void add_edge(const int &u,const int &v) {
    e[++en]={v,last[u]},last[u]=en;
    e[++en]={u,last[v]},last[v]=en;
}
int fa[N+5];
int dep[N+5],size[N+5];
int son[N+5],top[N+5];
void dfs1(const int &u) {
    dep[u]=dep[fa[u]]+1;
    size[u]=1;
    for(int i=last[u];i;i=e[i].next) {
        int &v{e[i].v};
        if(v==fa[u]) {
            continue;
        }
        fa[v]=u,dfs1(v);
        size[u]+=size[v];
        if(size[v]>size[son[u]]) {
            son[u]=v;
        }
    }
}
void dfs2(const int &u) {
    if(!top[u]) {
        top[u]=u;
    }
    if(son[u]) {
        top[son[u]]=top[u];
    }
    for(int i=last[u];i;i=e[i].next) {
        int &v{e[i].v};
        if(v==fa[u]) {
            continue;
        }
        dfs2(v);
    }
}
int LCA(int u,int v) {
    while(top[u]!=top[v]) {
        if(dep[top[u]]>dep[top[v]]) {
            u=fa[top[u]];
        }
        else {
            v=fa[top[v]];
        }
    }
    return dep[u]<dep[v]?u:v;
}
int distance(const int &u,const int &v) {
    return dep[u]+dep[v]-(dep[LCA(u,v)]<<1);
}
void clear(const int &n) {
    std::fill(last+1,last+n+1,0),en=0;
    std::fill(fa+1,fa+n+1,0);
    std::fill(son+1,son+n+1,0);
    std::fill(top+1,top+n+1,0);
}
int arr[N+5];
bool check(const int &n) {
    for(int i=1;i<=n;i++) {
        if(arr[i]!=i) {
            return false;
        }
    }
    return true;
}
constexpr int square(const int &x) {
    return x*x;
}
int calc(const int &u,const int &v) {
    return (square(distance(u,arr[v]))+square(distance(v,arr[u])))
          -(square(distance(u,arr[u]))+square(distance(v,arr[v])));
}
ll dp[N+5][2];
int lst[N+5];
void dfs3(const int &u) {
    dp[u][0]=0,dp[u][1]=0x3f3f3f3f3f3f3f3f;
    lst[u]=0;
    for(int i=last[u];i;i=e[i].next) {
        int &v{e[i].v};
        if(v==fa[u]) {
            continue;
        }
        dfs3(v);
        dp[u][1]+=std::min(dp[v][0],dp[v][1]);
        ll tmp{dp[u][0]+dp[v][0]+calc(u,v)};
        if(tmp<dp[u][1]) {
            lst[u]=v,dp[u][1]=tmp;
        }
        dp[u][0]+=std::min(dp[v][0],dp[v][1]);
    }
}
void dfs4(const int &u,const int &t,std::vector<int> &res) {
    for(int i=last[u];i;i=e[i].next) {
        int &v{e[i].v};
        if(v==fa[u]) {
            continue;
        }
        if(t==1&&v==lst[u]) {
            res.emplace_back(i+1>>1);
            std::swap(arr[u],arr[v]);
        }
        dfs4(v,t==1&&v==lst[u]?0:dp[v][1]<dp[v][0],res);
    }
}
void solve() {
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
        scanf("%d",arr+i);
    }
    clear(n);
    for(int i=1;i<n;i++) {
        int u,v;
        scanf("%d%d",&u,&v);
        add_edge(u,v);
    }
    dfs1(1),dfs2(1);
    std::vector<std::vector<int>> vec;
    while(!check(n)) {
        vec.emplace_back();
        dfs3(1),dfs4(1,dp[1][1]<dp[1][0],vec.back());
    }
    printf("%d\n",int(vec.size()));
    for(auto &x:vec) {
        std::sort(x.begin(),x.end());
        printf("%d",int(x.size()));
        for(int i=0;i!=x.size();i++) {
            printf(" %d",x[i]);
        }
        printf("\n");
    }
}
int main() {
    int t;
    scanf("%d",&t);
    while(t--) {
        solve();
    }
    return 0;
}