F2. The Hidden Pair (Hard Version)
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
Note that the only difference between the easy and hard version is the constraint on the number of queries. You can make hacks only if all versions of the problem are solved.
This is an interactive problem.
You are given a tree consisting of nn nodes numbered with integers from 11 to nn. Ayush and Ashish chose two secret distinct nodes in the tree. You need to find out both the nodes. You can make the following query:
- Provide a list of nodes and you will receive a node from that list whose sum of distances to both the hidden nodes is minimal (if there are multiple such nodes in the list, you will receive any one of them). You will also get the sum of distances of that node to the hidden nodes.
Recall that a tree is a connected graph without cycles. The distance between two nodes is defined as the number of edges in the simple path between them.
More formally, let's define two hidden nodes as ss and ff. In one query you can provide the set of nodes {a1,a2,…,ac}{a1,a2,…,ac} of the tree. As a result, you will get two numbers aiai and dist(ai,s)+dist(ai,f)dist(ai,s)+dist(ai,f). The node aiai is any node from the provided set, for which the number dist(ai,s)+dist(ai,f)dist(ai,s)+dist(ai,f) is minimal.
You can ask no more than 1111 queries.
Input
The first line contains a single integer tt (1≤t≤10)(1≤t≤10) — the number of test cases. Please note, how the interaction process is organized.
The first line of each test case consists of a single integer nn (2≤n≤1000)(2≤n≤1000) — the number of nodes in the tree.
The next n−1n−1 lines consist of two integers uu, vv (1≤u,v≤n,u≠v)(1≤u,v≤n,u≠v) — the edges of the tree.
Interaction
To ask a query print a single line:
- In the beginning print "? c " (without quotes) where cc (1≤c≤n)(1≤c≤n) denotes the number of nodes being queried, followed by cc distinct integers in the range [1,n][1,n] — the indices of nodes from the list.
For each query, you will receive two integers xx, dd — the node (among the queried nodes) with the minimum sum of distances to the hidden nodes and the sum of distances from that node to the hidden nodes. If the subset of nodes queried is invalid or you exceeded the number of queries then you will get x=d=−1x=d=−1. In this case, you should terminate the program immediately.
When you have guessed the hidden nodes, print a single line "! " (without quotes), followed by two integers in the range [1,n][1,n] — the hidden nodes. You can output the hidden nodes in any order.
After this, you should read a string. If you guess the nodes correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases or terminate the program, if all test cases were solved. Otherwise, you will receive the string "Incorrect". In this case, you should terminate the program immediately.
Guessing the hidden nodes does not count towards the number of queries asked.
The interactor is not adaptive. The hidden nodes do not change with queries.
Do not forget to read the string "Correct" / "Incorrect" after guessing the hidden nodes.
You need to solve each test case before receiving the input for the next test case.
The limit of 1111 queries applies to each test case and not to the entire input.
After printing a query do not forget to output the end of the line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
- fflush(stdout) or cout.flush() in C++;
- System.out.flush() in Java;
- flush(output) in Pascal;
- stdout.flush() in Python;
- see the documentation for other languages.
Hacks
To hack the solution, use the following test format:
The first line should contain a single integer tt (1≤t≤10)(1≤t≤10) — the number of test cases. The description of the test cases follows.
The first line of each test case should contain a single integer nn (2≤n≤1000)(2≤n≤1000) — the number of nodes in the tree. The second line should contain two distinct integers in the range [1,n][1,n] — the hidden nodes. The next n−1n−1 lines should contain two integers uu, vv (1≤u,v≤n,u≠v)(1≤u,v≤n,u≠v) — the edges of the tree.
Example
input
Copy
1 3 1 2 1 3 1 1 2 3 3 1 3 1 Correct
output
Copy
? 1 1 ? 1 2 ? 1 3 ? 2 2 3 ! 1 3
Note
The tree from the first test is shown below, and the hidden nodes are 11 and 33.
題意（互動題）：
給你n(<=1e3)，再給n-1條邊構成樹，你需要找到兩個節點u和v。
每次詢問給出n個點的下標，系統會回答你這n個點中，到u和v的距離之和最小的點x的下標（多個相同的隨機給你其中一個），和距離之和。
你最多使用不超過11次詢問，找出u和v。
思路：
剛看到這題的時候一臉懵逼，想了兩天也沒想出來。。。
實際上我們先查詢一次所有的點，這樣就可以得到一個位於路徑(u,v)之間的點rt，和u到v的距離sum。
以rt爲根，這樣建立的樹中，u和v的lca一定是rt。
這時我們只需要找出u，v其中一個點，然後以這個點爲根再重新建樹，查詢一次距離這個點sum的所有節點，就可以得到另一個點。
核心問題：怎麼找其中的一個點呢？
考慮使用二分。將所有的點先按照到rt的距離分類裝進vector，二分距離詢問對應的vector，根據得到的值是否大於sum來確定是否是位於u,v路徑上離rt最遠的一個點。
二分需要詢問最多10次，剛開始1次，最後找另一個點又1次，這一共是12次。接下來就是最神奇的操作：
由於u,v路徑上離rt最遠的一個點，到rt的距離>=(sum+1)/2，即sum/2向上取整。因此我們二分時，下界直接從(sum+1)/2開始，減少一次二分，就減少了一次詢問。
代碼：
#include<bits/stdc++.h>
#define ll long long
#define inf 0x3f3f3f3f
#define mst(head,x,n) memset(head+1,x,n*sizeof(head[0]))
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define dep(i,a,b) for(int i=(a);i>=(b);i--)
using namespace std;
const int maxn=1e3+5;
//const double pi=acos(-1.0);
//const double eps=1e-9;
//const ll mo=1e9+7;
int n,m,k;
int a[maxn],c[maxn];
int ans,tmp,cnt,rt,sum,ma;
int flag;
char s[maxn];
bool ok[maxn];
vector<int>vc[maxn],vv[maxn];
template <typename T>
inline void read(T &X){
X=0;int w=0; char ch=0;
while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
while(isdigit(ch)) X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
if(w) X=-X;
}
pair<int,int> query(int id){
printf("? %d",vv[id].size());
for(int i=0;i<vv[id].size();i++){
printf(" %d",vv[id][i]);
}
puts("");
fflush(stdout);
int x,y;
read(x);read(y);
return make_pair(x,y);
}
void dfs(int u,int fa,int dep){
ma=max(ma,dep);
vv[dep].push_back(u);
for(int i=0;i<vc[u].size();i++){
int v=vc[u][i];
if(v==fa) continue;
dfs(v,u,dep+1);
}
}
int jud(int as){
pair<int,int>k=query(as);
if(k.second>sum) return 1;
rt=k.first;
return 0;
}
int main(){
/*
#ifdef ONLINE_JUDGE
#else
freopen("D:/Temp/in.txt", "r", stdin);
#endif
*/
int T,cas=1;
read(T);
while(T--)
{
read(n);
ans=0;
rep(i,0,n+1) {vc[i].clear();vv[i].clear();}
rep(i,1,n-1){
int x,y;
read(x);read(y);
vc[x].push_back(y);
vc[y].push_back(x);
vv[n+1].push_back(i);
}
vv[n+1].push_back(n);
pair<int,int>tp=query(n+1);
rt=tp.first; sum=tp.second;
ma=0;
dfs(rt,-1,0);
//cout<<"* "<<endl;
ma=min(ma,sum);
int l=(sum+1)/2,r=ma+1,tmp;
while(l<r){
int mid=(l+r)>>1;
if(jud(mid)){
r=mid;
}
else {l=mid+1;tmp=mid;}
}
rep(i,0,n) vv[i].clear();
dfs(rt,-1,0);
tp=query(sum);
printf("! %d %d\n",rt,tp.first);
fflush(stdout);
scanf("%s",s);
}
return 0;
}
/*
1
3
1 2
1 3
1 1
*/