CF750F. New Year and Finding Roots

CF750F. New Year and Finding Roots

Solution

设当前节点为$x$，
若当前节点为叶子节点，则向它的邻居跑。
若当前节点为根，则找到答案。
否则，每次从$x$向两个方向找，每次只走一个没有走过的邻居，显然可以找到一条叶子节点到叶子节点的路径，即可算出当前路径上点的深度，再以这条路径上深度最小的节点重复刚才的操作。

这样的操作步数最多为$17$次，考虑到深度小于3的时候直接暴力枚举距离它不超过2的节点即可。

Code

（别问为什么这么长，还有奇怪的冗余操作，问就是爆了40发）

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <cassert>
#include <string.h>
//#include <unordered_set>
//#include <unordered_map>
//#include <bits/stdc++.h>
 
#define MP(A,B) make_pair(A,B)
#define PB(A) push_back(A)
#define SIZE(A) ((int)A.size())
#define LEN(A) ((int)A.length())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define fi first
#define se second
 
using namespace std;
 
template<typename T>inline bool upmin(T &x,T y) { return y<x?x=y,1:0; }
template<typename T>inline bool upmax(T &x,T y) { return x<y?x=y,1:0; }
 
typedef long long ll;
typedef unsigned long long ull;
typedef long double lod;
typedef pair<int,int> PR;
typedef vector<int> VI;
 
const lod eps=1e-11;
const lod pi=acos(-1);
const int oo=1<<30;
const ll loo=1ll<<62;
const int mods=1e9+7;
const int MAXN=600005;
const int INF=0x3f3f3f3f;//1061109567
/*--------------------------------------------------------------------*/
inline int read()
{
	int x;
	scanf("%d",&x);
	return x;
}
vector<int> V[150];
int vis[150],dep[150],Flag,h,Time=0;
void Read(int x) 
{ 
	if (Flag||vis[x]) return;
	if ((++Time)==17) { printf("! %d\n",x),fflush(stdout),Flag=1; return; }
	printf("? %d\n",x),fflush(stdout); 
	int p=read(); 
	vis[x]=1;
	while (p--) V[x].PB(read());
}
void solve(int x,int dep)
{
	if (!vis[x]) 
	{
		Read(x);
		if (Flag) return;
		if (V[x].size()==2) { printf("! %d\n",x),Flag=1,fflush(stdout); return; }
	}
	for (auto v:V[x])
	{
		if (vis[v]) continue; 
		Read(v);
		if (Flag) return;
		if (V[v].size()==2) { printf("! %d\n",v),Flag=1,fflush(stdout); return; }
		if (h-dep==2)
		for (auto u:V[v])
		{
			if (vis[u]) continue; Read(u);
			if (Flag) return;
			if (V[u].size()==2) { printf("! %d\n",u),Flag=1,fflush(stdout); return; }	
		}
	}
}
void dfs(int x)
{
	if (vis[x]||Flag) return; 
	Read(x);
	if (Flag) return;
	if (V[x].size()==1) { dep[x]=1; return; }
	if (V[x].size()==2) { printf("! %d\n",x),fflush(stdout),Flag=1; return; }
	for (auto v:V[x])
		if (!vis[v]) { dfs(v),dep[x]=dep[v]+1; break; }
}
void Dfs(int x)
{
	if (Flag) return;
	if (dep[x]!=INF&&h-dep[x]<=2) { solve(x,dep[x]); return; }
	Read(x);
	if (Flag) return;
	if (V[x].size()==1) { dep[x]=1,dep[V[x][0]]=2,Dfs(V[x][0]); return; }
	if (V[x].size()==2) { printf("! %d\n",x),Flag=1,fflush(stdout); return; }
	
	if (vis[V[x][2]]) swap(V[x][0],V[x][2]);
	if (vis[V[x][2]]) swap(V[x][1],V[x][2]);
	dfs(V[x][0]); if (Flag) return;
	dfs(V[x][1]); if (Flag) return;
	dep[x]=min(dep[V[x][0]],dep[V[x][1]])+1;
	if (dep[V[x][0]]==dep[V[x][1]]) dep[V[x][2]]=dep[x]+1,Dfs(V[x][2]);
	else 
	{	
		if (dep[V[x][0]]<dep[V[x][1]]) swap(V[x][0],V[x][1]);
		int len=dep[x]+dep[V[x][0]],lst=x;
		for (int j=dep[x]+1,nw=V[x][0];j<=len/2+1;j++)
		{
			dep[nw]=j;
			for (auto v:V[nw])
				if (vis[v]&&v!=lst) { lst=nw,nw=v; break; }
		}
		for (auto v:V[lst])
			if (!vis[v]) { dep[v]=dep[lst]+1,Dfs(v); break; }
	}
}
signed main()
{
	srand(time(0));
	int Case=read();
	while (Case--)
	{
		for (int i=0;i<=128;i++) vis[i]=0,dep[i]=INF,V[i].clear();
		h=read(),Flag=0,Time=0,Dfs(rand()%((1<<h)-2)+1);
	}
	return 0;
}