#include <bits/stdc++.h>
#define mis(x) cout << #x <<" = " <<x<<endl
#define rep(i, a, b) for(int i=(a);(i)<(b);(i)++)
#define re(i,a) rep((i),0,(a))
#define eb emplace_back
#define x first
#define y second
	//	#define cin fin
using namespace std;
typedef long long ll;
ifstream fin("Sisend.txt");
//ifstream fin("tagavarafail.txt");
void ye(bool b){cout<<(b? "Yes\n":"NO\n");}
const int Ia = INT_MAX, Ii INT_MIN;
ll tt,t,n,m,k,c;
struct item{
	int i,l,r,w;
	bool vas=0;
	vector<int> v;
	void alg(int k){
		i=k,vas=0;
	}
	void paneLR(vector<item> &it,int &in,int yl){
		l=in++;
		sort(v.begin(),v.end());
		for(int j:v)if(j!=yl)	it[j].paneLR(it,in,i);
		r=in;
		return;
	}
};
bool boo(item &a,item &b){
	if(a.w == b.w ) return a.l > b.l;
	return a.w > b.w;
}
struct Node {		//vt v�ikseim aeg, st suurim, vr v�ikseim parem kaug, sr suurim 
    int vt, st, vr, sr, vvr;		//vvr v�ikseim v�ikseima t-ga paremp kaugus
    bool ord,sees,seesk;	//ord �ige j�rjekord, seesk - k�ik �ksteise sees, sees - v�iksemad v�ivad olla k�rvuti
};

class SegmentTree {
    int n,cc;
    vector<Node> t;
    vector<int> Vt,St,Vr,Sr,Vvr;
	vector<bool> Ord,Sees,Seesk;
public:
    SegmentTree(int size) {
        n = size;
        cc=1;while(cc<n)cc<<=1;int d=2*cc+5;
        t.resize(d, {Ia, Ii, Ia, Ii, Ia, true, true, true});
        Vt.resize(d,Ia),St.resize(d,Ii),Vr.resize(d,Ia),Sr.resize(d,Ii),Vvr.resize(d,Ia);
        Ord.resize(d,1),Sees.resize(d,1),Seesk.resize(d,1);
    }
bool leiaSees(int a,int b){
	if(!Sees[a] || !Sees[b])	return false;
	if(Vt[a]	==Ia || 	Vt[b]	==Ia) 	return true; 				//�hte polegi
	if(Vt[a]	==Vt[b])	return Vr[a]>=Sr[b];				//vasak sisaldab paremat
	if(Vt[a]	> Vt[b])	return min(Vr[a],Vvr[a])>=Sr[b];	//vasakpoolses peab ka esimesena pandu sisaldama parempoolset
	return 	Vr[a]>=Sr[b] && Seesk[b];
}
int leiaVr(int a, int b){
	if(Vt[a]	==	Vt[b])	return min(Vr[a],Vr[b]);
	if(Vt[a]	<	Vt[b])	swap(a,b);	//nodes a on hiljem pandud esimene
	if(Vt[a]	==	Ia)		return Vr[b];
	return min(	min(Vr[a],Vvr[a]),	Vr[b]);
}
int leiaVvr(int a, int b){
	if(Vt[a]	==	Vt[b] || Vt[a]==Ia || Vt[b]==Ia)return min(Vvr[a],Vvr[b]);
	return (Vt[a]<Vt[b])? Vvr[a] : Vvr[b];
}
void modify(int p,int ti,int r) {  // set value at position p
	int pp=p;
	p+=cc;
	Vt[p] = ti, St[p] = ti, Ord[p] = 1, Sr[p]=r, Vvr[p]=r;
  	for (p>>=1; p >= 1; p >>= 1){
  		int a=p<<1,b=(p<<1)+1;
  		Vr[p] 	= leiaVr(a,b);				//minimaalne parempoolne
  		Vvr[p]	= leiaVvr(a,b);			//minimaalne parempoolne v�ikseimate aegade hulgast
   		Sr[p] 	= max(Sr[a],Sr[b]),		// piir selle piirkonna punktide alluvatel
    	Vt[p] 	= min(Vt[a],Vt[b]),
		St[p] 	= max(St[a],St[b]),
		Ord[p] 	= Ord[a] 	&& 	Ord[b] 	&& 	Vt[a]>=St[b] ; // ord : kas parempoolse on pandud enne  	
		Sees[p]	= leiaSees(a,b);
		Seesk[p]	= Seesk[a] && Seesk[b] && min(Vr[a],Vvr[a])>=Sr[b];
  	} 
  	return;
}
int leia(vector<int> &t,int l, int r,int res, function<int(int, int)> f){
  for (l += cc, r += cc; l < r; l >>= 1, r >>= 1) {
    if (l&1)  	res = f(res,t[l++]);
    if (r&1)	res = f(res,t[--r]);
  }
  return res;	
}	
int vt(int l, int r){
	return leia(Vt,	l,r,Ia,[](int x,int y) -> int { return min(x,y);});	
}
int vvr(int l, int r){
	return leia(Vvr,l,r,Ia,[](int x,int y) -> int { return min(x,y);});
}
int sr(int l, int r){
	return leia(Sr,	l,r,Ii,[](int x,int y) -> int { return max(x,y);});	
}
int st(int l, int r){
	return leia(St,	l,r,Ii,[](int x,int y) -> int { return max(x,y);});
}
int vr(int l, int r){
  int res = Ia;
  int ti=vt(l,r);
  for (l += cc, r += cc; l < r; l >>= 1, r >>= 1) {
    if (l&1){
    	if(Vt[r]!=ti)res = min(res,Vvr[l]);
    	res = min(res,Vr[l++]);
	}  	
    if (r&1){
    	res = min(res,Vr[--r]);
		if(Vt[r]!=ti)res=min(res,Vvr[r]);
	}	
  }
  return res;	
}
bool seesk(int l, int r){
	bool res=1;
	int vas=Ia,par=Ii;
	  for (l += cc, r += cc; l < r; l >>= 1, r >>= 1) {
	    if (l&1){
	    	res = res && Seesk[l] && vas >= Sr[l] ;
	    	vas = min(vas,min(Vr[l],Vvr[l]));
			l++;	
	 	}	
	    if (r&1){
	    	res = res && Seesk[--r] && min(Vr[r],Vvr[r]) >= par;
	    	par=max(par,Sr[r]);
		}
	  }	
  	res= res && vas>= par;
  return res;	
}
bool sees(int l,int r){
	bool res=1;
	int ti = vt(l,r);
	int vas=Ia,par=Ii;
	  for (l += cc, r += cc; l < r; l >>= 1, r >>= 1) {
	    if (l&1){
	    	res = res && Sees[l] && vas >= Sr[l] ;
	    	vas = min(vas,Vr[l]);
	    	if(Vt[l] != ti){
	    		res = res && Seesk[l];
	    		vas = min(vas,Vvr[l]);
			}
			l++;	
	 	}	
	    if (r&1){
	    	res = res && Sees[--r] && Vr[r] >= par;
			if(Vt[r] != ti)	res = res && Seesk[r] && Vvr[r] >= par;
	    	par=max(par,Sr[r]);
		}
	  }	
  	res= res && vas>= par;
  return res;
}
bool query(int l, int r){
	bool res = sees(l,r);
	
	int lp=l,rp=r;
	int vas=Ia,par=Ii;
	for (l += cc, r += cc; l < r; l >>= 1, r >>= 1) {
		if (l&1){
	     	res = res && Ord[l] && vas>= St[l];
	    	vas=min(vas,Vt[l++]);
		}	
	    if (r&1){
	    	res = res && Ord[--r] && Vt[r] >= par;
	    	par=max(par,St[r]);
	 	} 
	}
  	res= res && vas>= par; 
  return res;	
}
};
int main(){
    freopen("in","r",stdin);
    freopen("out1","w",stdout);
	ios::sync_with_stdio(0);cin.tie(0);	cout.tie(0);cerr.tie(0);
	cin>>tt;while(tt--){
		cin>>n;
		vector<item> it(n);
		re(i,n){
			it[i].alg(i);
			cin>>it[i].w;
		}
		re(i,n-1){
			int a,b;cin>>a>>b;a--,b--;
			it[a].v.eb(b),it[b].v.eb(a);
		}
		int in=0;
		it[0].paneLR(it,in,-1);//l�bib graafi, leiab iga node alluvate piirid, node ise asub kohal l;
		sort(it.begin(),it.end(),boo); //suuremad v��rtused enne
	   	SegmentTree t(n);
		in=0;int tase=0;
		re(i,n){
			if( i and it[i].w < it[i-1].w ){
				tase++;
				in=i;
				while(in<n-1 and it[in+1].w==it[in].w)in++;
				for(int j = i; j <= in ; j++){
					int c=Ia,d=Ia; 
					if(it[j].l)c = t.vt( 0, it[j].l );
					if(it[j].r<n)d = t.vt( it[j].r, n );
					
					if(c == Ia){							
						if(d!=Ia)	it[j].vas = t.query(it[j].r,n);
					}			
					else{
						if(d==Ia){
							
							it[j].vas = t.query(0,it[j].l);
							
						}	
						else if(c>=d){
							bool res= t.query(0,it[j].l) && t.query(it[j].r,n);
							if(c==d){//paremal saavad olla vaid v�ikseimad
								res= res && t.vr(0,it[j].l)>= t.sr(it[j].r,n) && d == t.st( it[j].r, n );
							}else if(c>d){//paremas esimesena pandud
								res= res &&	 min(t.vvr(0,it[j].l),t.vr(0,it[j].l)) >= t.sr(it[j].r,n) &&
									 t.seesk(0,it[j].l) && c>=t.st( it[j].r, n );
							}
							it[j].vas=res;
						}
					}
				}
				if(in==n-1)break;
			}
			t.modify(it[i].l,tase,it[i].r);
		}
		vector<int> v;
		re(i,n)if(it[i].vas)v.eb(it[i].i+1);
		sort(v.begin(),v.end());
		cout<<v.size()<<" ";
		for(int i:v)cout<<i<<" ";
		cout<<"\n";
	}
}

#if defined(_USE_PCH_)
#include "pch.hpp"
#else
#include <bits/stdc++.h>
#endif
#define RNG(V_, A_, B_, ...) for(int V_=(A_), V_##_END=(B_) __VA_OPT__(,) __VA_ARGS__; V_<=V_##_END; V_++)
#define IRNG(V_, A_, B_, ...) for(int V_=(A_), V_##_END=(B_) __VA_OPT__(,) __VA_ARGS__; V_>=V_##_END; V_--)
#ifdef _WIN32
#define long int64_t
#endif
#define fir first
#define sec second
#define _UN using namespace
using namespace std;
typedef pair<int,int> pii;
typedef __int128 i128;
const int MAXN=4e5+10,INF=0x3f3f3f3f,NINF=0xc0c0c0c0; const long INFL=0x3f3f3f3f3f3f3f3f;
int n,A[MAXN]; vector<int> G[MAXN],del[MAXN];
int dfn[MAXN],dfne[MAXN],dfnc;
int ord[MAXN],mx[MAXN]; vector<int> ans;
void dfs1(int u,int fa_,int mx_){
    dfn[u]=++dfnc,mx[u]=mx_;
    for(int v:G[u]){
        if(v!=fa_) dfs1(v,u,max(mx_,A[u]));
    }
    dfne[u]=dfnc;
}
struct X{ long mx,mxc; };
X operator+(X x,X y){ return {max(x.mx,y.mx),(x.mx==max(x.mx,y.mx)?x.mxc:0)+(y.mx==max(x.mx,y.mx)?y.mxc:0)}; }
X operator+(X x,long y){ x.mx+=y; return x; }
struct SGT2{
#define ls (u<<1)
#define rs (u<<1|1)
    const static int MAXN=1<<20;
    X mx[MAXN]; long tag[MAXN]; int len;
    void init(){
        for(len=1; len<(n+2); len<<=1) ;
        fill_n(mx,len*2,X{NINF,0}),fill_n(tag,len*2,0);
    }
    void pushup(int u){ mx[u]=(mx[ls]+tag[ls])+(mx[rs]+tag[rs]); }
    void upd(int i,X x){
        int u=len+i; mx[u]=x;
        for(u>>=1; u; u>>=1) pushup(u);
    }
    void upd(int l,int r,long x){
        int u=len+l-1,v=len+r+1;
        for(; u^v^1; u>>=1,v>>=1,pushup(u),pushup(v)){
            if(~u&1) tag[u^1]+=x;
            if( v&1) tag[v^1]+=x;
        }
        for(; u; u>>=1,v>>=1) pushup(u);
    }
    X qry(int l,int r){
        if(l>r) return {NINF,0};
        X retl{NINF,0},retr{NINF,0};
        int u=len+l-1,v=len+r+1;
        for(; u^v^1; u>>=1,v>>=1,retl=retl+tag[u],retr=retr+tag[v]){
            if(~u&1) retl=retl+(mx[u^1]+tag[u^1]);
            if( v&1) retr=retr+(mx[v^1]+tag[v^1]);
        }
        for(; u; u>>=1,v>>=1,retl=retl+tag[u],retr=retr+tag[v]) ;
        return retl+retr;
    }
#undef ls
#undef rs
} sgt1;
struct BIT{
    int A[MAXN];
    void init(){ fill_n(A+1,n,0); }
    void upd(int i,int x){
        for(; i<=n; i+=i&-i) A[i]+=x;
    }
    int qry(int i){
        int ret=0;
        for(; i; i-=i&-i) ret+=A[i];
        return ret;
    }
    int qry(int l,int r){ return l<=r?qry(r)-qry(l-1):0; }
} bit,bit2;
int curcas;
void case_main(){
    cin>>n;
    RNG(i,1,n) cin>>A[i];
    RNG(i,1,n) G[i].clear(),del[i].clear();
    RNG(_,1,n-1,u,v) cin>>u>>v,G[u].push_back(v),G[v].push_back(u);
    sgt1.init(); bit.init(); bit2.init();
    dfnc=0; dfs1(1,0,0);
    iota(ord+1,ord+n+1,1),sort(ord+1,ord+n+1,[](int u,int v){ return A[u]>A[v]; });
    ans.clear();
    vector<int> vec;
    RNG(p,1,n){
        {
            int u=ord[p];
            auto x=bit.qry(1,dfn[u]-1)+bit.qry(dfne[u]+1,n);
            auto z=bit2.qry(1,dfn[u]-1)+bit2.qry(dfne[u]+1,n);
            auto y=sgt1.qry(1,dfn[u]-1)+sgt1.qry(dfne[u]+1,n);
            if(!z&&x&&y.mx<INF&&x==y.mx%(n+1)+y.mxc-1) ans.push_back(u);
            vec.push_back(u);
        }
        if(A[ord[p+1]]!=A[ord[p]]){
            sort(vec.begin(),vec.end(),[](int v1,int v2){ return dfn[v1]>dfn[v2]; });
            for(int u:vec){
                bit.upd(dfn[u],1);
                sgt1.upd(dfn[u],{1l*A[u]*(n+1),1});
                sgt1.upd(dfn[u],dfne[u],1);
                if(mx[u]>A[u]) bit2.upd(dfn[u],1),bit2.upd(dfne[u]+1,-1);
            }
            vec.clear();
        }
    }
    sort(ans.begin(),ans.end());
    cout<<ans.size()<<" ";
    for(int u:ans) cout<<u<<" ";
    cout<<"\n";
}
int main(){
#if defined(_LOCAL_)
    freopen("in","r",stdin);
    freopen("out","w",stdout);
//  freopen("/dev/null","w",stderr);
#else
//  freopen("tree.in","r",stdin);
//  freopen("tree.out","w",stdout);
#endif
    ios::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr);
    int cas; cin>>cas;
    RNG(_,1,cas) curcas=_,case_main();
}

1
10
1 1 6 3 6 3 7 4 4 7 
1 2
1 3
2 4
2 5
5 6
4 7
6 8
6 9
4 10