CF750F. New Year and Finding Roots
Solution
设当前节点为
x
x
x,
若当前节点为叶子节点,则向它的邻居跑。
若当前节点为根,则找到答案。
否则,每次从
x
x
x向两个方向找,每次只走一个没有走过的邻居,显然可以找到一条叶子节点到叶子节点的路径,即可算出当前路径上点的深度,再以这条路径上深度最小的节点重复刚才的操作。
这样的操作步数最多为 17 17 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;
}