huawei code2

#include <ctime>
#include <vector>
#include <bitset>
#include <cstdio>
#include <random>
#include <cassert>
#include <algorithm>
#include <unordered_map>
const int Maxn=5000;
const int Maxm=5000;
const int Inf=0x3f3f3f3f;
int n,m;
int w[Maxn+5];
bool vis[Maxn+5];
struct Graph{
	int deg[Maxn+5];
	int head[Maxn+5],arrive[Maxm+5],nxt[Maxm+5],tot;
	int lis[Maxn+5],lis_len;
	void add_edge(int from,int to){
		arrive[++tot]=to;
		nxt[tot]=head[from];
		head[from]=tot;
		deg[to]++;
	}
	std::bitset<Maxn+5> g[Maxn+5];
	void init(){
		lis_len=0;
		tot=0;
		for(int i=1;i<=n;i++){
			deg[i]=0;
			g[i].reset();
			head[i]=0;
		}
	}
	void work(){
		static int qu[Maxn+5],qu_f,qu_t;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				g[i][j]=1;
			}
		}
		qu_f=1,qu_t=0;
		for(int i=1;i<=n;i++){
			if(deg[i]==0){
				g[i].reset();
				qu[++qu_t]=i;
			}
		}
		lis_len=0;
		while(qu_f<=qu_t){
			int u=qu[qu_f++];
			lis[++lis_len]=u;
			g[u][u]=1;
			for(int i=head[u];i;i=nxt[i]){
				int v=arrive[i];
				deg[v]--;
				g[v]&=g[u];
				if(deg[v]==0){
					qu[++qu_t]=v;
				}
			}
		}
	}
}g[2];
std::mt19937 rnd(0);
std::bitset<Maxn+5> val[Maxn+5];
std::unordered_map<std::bitset<Maxn+5>,int> mp_ans;
int d_tot;
int bel[Maxn+5];
std::bitset<Maxn+5> d[Maxn+5];
int d_id[Maxn+5];
bool cmp_count(int id_a,int id_b){
	return d[id_a].count()>d[id_b].count();
}
std::bitset<Maxn+5> d_g[Maxn+5];
bool dfs_vis[Maxn+5];
std::vector<int> ans_lis[Maxn+5];
bool all_flag[Maxn+5];
std::pair<int,int> d_sum[Maxn+5];
void init(){
	g[0].init(),g[1].init();
	for(int i=1;i<=n;i++){
		val[i].reset();
		vis[i]=0;
		bel[i]=0;
		dfs_vis[i]=0;
		all_flag[i]=0;
		d_sum[i]=std::make_pair(0,0);
	}
	mp_ans.clear();
	d_tot=0;
	for(int i=1;i<=n;i++){
		d_g[i].reset();
		ans_lis[i].clear();
	}
}
bool check_all(int u){
	for(int i=0;i<(int)ans_lis[u].size();i++){
		if(vis[ans_lis[u][i]]){
			return 0;
		}
	}
	return 1;
}
std::pair<int,int> calc_val(std::vector<int> a){
	static int f_val[Maxn+5][2],g_val[Maxn+5][2];
	static bool a_vis[Maxn+5];
	for(int i=1;i<=n;i++){
		a_vis[i]=0;
		f_val[i][0]=f_val[i][1]=0,g_val[i][0]=g_val[i][1]=Inf;
	}
	for(int i=0;i<(int)a.size();i++){
		a_vis[a[i]]=1;
	}
	if(a_vis[1]){
		f_val[1][0]=-Inf,g_val[1][0]=Inf;
		f_val[1][1]=w[1],g_val[1][1]=w[1];
	}
	else{
		g_val[1][0]=0;
	}
	for(int i=2;i<=g[0].lis_len;i++){
		int u=g[0].lis[i];
		for(int j=g[1].head[u];j;j=g[1].nxt[j]){
			int v=g[1].arrive[j];
			f_val[u][0]=std::max(f_val[u][0],f_val[v][0]);
			g_val[u][0]=std::min(g_val[u][0],g_val[v][0]);
			f_val[u][1]=std::max(f_val[u][1],f_val[v][1]);
			g_val[u][1]=std::min(g_val[u][1],g_val[v][1]);
		}
		if(a_vis[u]){
			f_val[u][1]=std::max(f_val[u][1],f_val[u][0])+w[u];
			g_val[u][1]=std::min(g_val[u][1],g_val[u][0])+w[u];
			f_val[u][0]=-Inf,g_val[u][0]=Inf;
		}
	}
	return std::make_pair(f_val[n][1],g_val[n][1]);
}
void work_dfs(int u){
	if(ans_lis[u].empty()||dfs_vis[u]){
		return;
	}
	d_sum[u]=std::make_pair(0,0);
	for(int i=0;i<(int)ans_lis[u].size();i++){
		d_sum[u].first+=w[ans_lis[u][i]];
	}
	d_sum[u].second=d_sum[u].first;
	all_flag[u]=1;
	std::vector<int> son;
	dfs_vis[u]=1;
	for(int v=1;v<=n;v++){
		if(u==v||d_g[u][v]==0){
			continue;
		}
		if(dfs_vis[v]){
			all_flag[u]=0;
			if(!ans_lis[v].empty()&&check_all(v)){
				son.push_back(v);
			}
			continue;
		}
		work_dfs(v);
		if(!all_flag[v]){
			all_flag[u]=0;
		}
		if(check_all(v)){
			son.push_back(v);
		}
		else{
			all_flag[u]=0;
		}
	}
	if(son.empty()){
		return;
	}
	std::sort(son.begin(),son.end(),[&](int p,int q){return d_sum[p].first<d_sum[q].first;});
	if(all_flag[u]){
		std::vector<int> tmp_lis=ans_lis[u];
		for(int i=0;i<(int)son.size();i++){
			int v=son[i];
			for(int j=0;j<(int)ans_lis[v].size();j++){
				tmp_lis.push_back(ans_lis[v][j]);
			}
		}
		std::pair<int,int> tmp_val=calc_val(tmp_lis);
		if(1.0*tmp_val.second>=0.9*tmp_val.first){
			for(int i=0;i<(int)son.size();i++){
				int v=son[i];
				for(int j=0;j<(int)ans_lis[v].size();j++){
					ans_lis[u].push_back(ans_lis[v][j]);
				}
				ans_lis[v].clear();
			}
			d_sum[u]=tmp_val;
			return;
		}
	}
	for(int i=0;i<(int)son.size();i++){
		int v=son[i];
		std::vector<int> tmp_lis=ans_lis[u];
		for(int j=0;j<(int)ans_lis[v].size();j++){
			tmp_lis.push_back(ans_lis[v][j]);
		}
		std::pair<int,int> tmp_val=calc_val(tmp_lis);
		if(1.0*tmp_val.second>=0.9*tmp_val.first){
			for(int j=0;j<(int)ans_lis[v].size();j++){
				ans_lis[u].push_back(ans_lis[v][j]);
			}
			ans_lis[v].clear();
		}
	}
	d_sum[u]=calc_val(ans_lis[u]);
}
void solve(){
	scanf("%d",&n);
	init();
	for(int i=1;i<=n;i++){
		scanf("%d",&w[i]);
	}
	{
		int k;
		scanf("%d",&k);
		for(int i=1;i<=k;i++){
			int a;
			scanf("%d",&a);
			vis[a]=1;
		}
	}
	scanf("%d",&m);
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		g[0].add_edge(u,v),g[1].add_edge(v,u);
	}
	g[0].work(),g[1].work();
	for(int i=1;i<=n;i++){
		val[i]=g[0].g[i]|g[1].g[i];
	}
	for(int i=1;i<=n;i++){
		if(mp_ans.count(val[i])>0){
			bel[i]=mp_ans[val[i]];
		}
		else{
			bel[i]=mp_ans[val[i]]=++d_tot;
			d[d_tot]=val[i];
		}
	}
	for(int i=1;i<=d_tot;i++){
		d_sum[i]=std::make_pair(0,0);
	}
	for(int i=1;i<=n;i++){
		ans_lis[bel[i]].push_back(i);
		d_sum[bel[i]].first+=w[i],d_sum[bel[i]].second+=w[i];
	}
	if(clock()*1.0/CLOCKS_PER_SEC>19.0){
		int num=0;
		for(int i=1;i<=n;i++){
			if(!vis[i]){
				num++;
			}
		}
		printf("%d ",num);
		for(int i=1;i<=n;i++){
			if(!vis[i]){
				printf("%d ",i);
			}
		}
		puts("");
		printf("%d\n",d_tot);
		for(int i=1;i<=d_tot;i++){
			printf("%u ",ans_lis[i].size());
			for(int j=0;j<(int)ans_lis[i].size();j++){
				printf("%d ",ans_lis[i][j]);
			}
			puts("");
		}
		return;
	}
	for(int i=1;i<=d_tot;i++){
		d_id[i]=i;
	}
	std::sort(d_id+1,d_id+1+d_tot,cmp_count);
	for(int i=1;i<=d_tot;i++){
		d_g[d_id[i]][d_id[i]]=1;
		for(int j=i-1;j>0;j--){
			if(d_g[d_id[i]][d_id[j]]){
				continue;
			}
			if((d[d_id[i]]&d[d_id[j]])==d[d_id[i]]){
				d_g[d_id[i]]|=d_g[d_id[j]];
			}
		}
	}
	static int tmp_id[Maxn+5];
	for(int i=1;i<=d_tot;i++){
		tmp_id[i]=i;
	}
	int T_num=6;
	static std::vector<int> answer_lis[Maxn+5];
	int answer_len=d_tot;
	double answer_sum=d_tot;
	for(int i=1;i<=d_tot;i++){
		answer_lis[i]=ans_lis[i];
	}
	std::sort(tmp_id+1,tmp_id+1+d_tot,cmp_count);
	while(T_num--){
		for(int i=1;i<=d_tot;i++){
			dfs_vis[i]=0;
			ans_lis[i].clear();
		}
		for(int i=1;i<=n;i++){
			ans_lis[bel[i]].push_back(i);
		}
		for(int i=1;i<=d_tot;i++){
			if(dfs_vis[tmp_id[i]]){
				continue;
			}
			work_dfs(tmp_id[i]);
		}
		int tmp_ans=0;
		double tmp_sum=0;
		for(int i=1;i<=d_tot;i++){
			if(ans_lis[i].empty()){
				continue;
			}
			tmp_ans++;
			tmp_sum+=1ll*d_sum[i].second/d_sum[i].first;
		}
		if(tmp_ans<answer_len||(tmp_ans==answer_len&&tmp_sum>answer_sum)){
			answer_len=tmp_ans;
			answer_sum=tmp_sum;
			for(int i=1;i<=d_tot;i++){
				answer_lis[i]=ans_lis[i];
			}
		}
		std::shuffle(tmp_id+1,tmp_id+1+d_tot,rnd);
	}
	/*(int i=d_tot;i>0;i--){
		if(dfs_vis[d_id[i]]){
			continue;
		}
		work_dfs(d_id[i]);
	}*/
	for(int i=1;i<=d_tot;i++){
		ans_lis[i]=answer_lis[i];
	}
	int all_num=0;
	int add_num=0;
	static int add_lis[Maxn+5];
	for(int i=1;i<=d_tot;i++){
		if(ans_lis[i].empty()){
			continue;
		}
		all_num++;
		bool flag=0;
		for(int j=0;j<(int)ans_lis[i].size();j++){
			if(vis[ans_lis[i][j]]){
				flag=1;
				break;
			}
		}
		if(!flag){
			for(int j=1;j<=n;j++){
				if(bel[j]==i){
					add_lis[++add_num]=j;
					break;
				}
			}
		}
	}
	printf("%d ",add_num);
	for(int i=1;i<=add_num;i++){
		printf("%d ",add_lis[i]);
	}
	puts("");
	printf("%d\n",all_num);
	for(int i=1;i<=d_tot;i++){
		if(ans_lis[i].empty()){
			continue;
		}
		printf("%u ",ans_lis[i].size());
		for(int j=0;j<(int)ans_lis[i].size();j++){
			printf("%d ",ans_lis[i][j]);
		}
		puts("");
	}
}
int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		solve();
	}
	return 0;
}