#include"tree.h"
#include<bits/stdc++.h>
using namespace std;
const int maxn=1005;
vector<int> V[maxn],V2[maxn];
vector<int> G[maxn];
int Fa[maxn]; 
void solve(int l,int r,int fa,int dep){
	vector<int> now;
	for(int i=l;i<=r;i++) now.push_back(V[dep][i]); 
	int sum=ask(fa,now);
	int sum2=ask(Fa[fa],now); 
	/*
	x+y=r-l+1
	x-y=sum2-sum
	*/
	int delta=sum2-sum;
	int x=(delta+r-l+1)/2;
	if(!x) return ;
	if(x==r-l+1){
		for(int i=l;i<=r;i++){
			Fa[V[dep][i]]=fa;
			G[fa].push_back(V[dep][i]);
		}
		return ;
	}
	if(l==r){
		Fa[V[dep][l]]=fa;
		G[fa].push_back(V[dep][l]);
		return ;
	}
	int mid=(l+r)>>1;
	solve(l,mid,fa,dep);
	solve(mid+1,r,fa,dep);
}
void solver(int n,int A,int B){
	if(n*(n-1)/2<=5e5){
		for(int i=1;i<=n;i++){
			for(int j=i+1;j<=n;j++){
				vector<int> now;
				now.push_back(j);
				if(ask(i,now)==1) answer(i,j);
			}
		} 
		return ;
	} 
	for(int i=2;i<=n;i++){
		vector<int> now;
		now.push_back(i);
		int dep=ask(1,now);
		V[dep].push_back(i);
		V2[dep].push_back(i);
		if(dep==1) G[1].push_back(i),Fa[i]=1; 
	}
	for(int i=2;i<=n;i++){//对于每个dep分别找父亲
		for(auto fa:V2[i-1]){
			if(!V[i].size()) break;
			solve(0,V[i].size()-1,fa,i);
			for(auto x:G[fa]){
				V[i].erase(find(V[i].begin(),V[i].end(),x));
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(auto y:G[i]){
			answer(i,y);
		}
	}
}
/*
感觉这个题目有意思。
考虑一种很 SB 的暴力。
我每个点询问其他所有点当边权为 1 时即可回答。
复杂度： n*(n-1)/2，期望 3pts。
每次多问一些。
我先确定一个点作为根总要好一些吧。
我让 1 把所有点问一次，找到他的儿子。
这样树的形态初步建成。
我感觉 sub 2 那 17pts 卡一卡就能卡过去。
一次多问一些有用的信息是不是好一些。 
树是有父亲的，我找到每个点的父亲就能确定心态。
我第一次 1 问的时候相当于明确了每个点的深度。
一个点的父亲只能是他的深度-1。
考虑寻找自己父亲的过程，如果单独询问，答案要么是 1 或者是 dep*2-1 都可以直接确定。
意味着我可以像解方程一样解出哪些点是他的儿子。
然后可以用一种类似于分治的做法递归处理。
次数 nlogn，集合大小  n^2,足够我通过前三档包了。
还剩最后一部分。
最后一档有点难处理，要求我用线性的询问次数，低于 n^2 的集合大小。
先写再说吧，人类的智慧是有限度的。 
干的漂亮，假了，距离不一定要走到根，他只要走到 lca 就好了。
我们要判断什么? 一段区间中至少存在一个他的儿子吗？
说不明白，判断不了，最简单的反例：1+5=3+3。
换种思路，我让他们先配好对这样一个对对应一个父亲会好做一些吗？
延续刚才的思路，我再多问一次父亲，看他们差就好了，每个点的差要么为1要么为-1就很好。 
*/