CF1746E Joking

CF1746E Joking

交互库最开始给定一个正整数 \(n\)，并生成一个 \(x \in [1, n]\)，你的目标是得到交互库中的 \(x\)。

你可以向交互库提出问题：

提问一个集合 \(S\)，交互库回答的内容是 \(x \in S\) 的真假。该提问次数不能超过限制数 \(Q\)。

交互库可以骗人，也即交互库的回答不一定正确。但保证 交互库连续的两次回答中，至少有一次是正确的。

你还可以向交互库提交答案，直接提交一个正整数 \(i\)。你只有 \(2\) 次提交答案的机会。

保证 \(1 \le n \le 10^5\)。交互库是自适应性的，它会通过某种神奇策略动态改变 \(x\)，使得它仍然满足它所回答过你的所有问题，保证交互正确性的同时，尽可能让你慢地猜出答案。

E1 Easy Version

在 Easy Version 中，限制参数 \(Q = 82\)。

观察到提交答案的机会只有 \(2\) 次，因此中途就提交答案并不是特别明智。但直接放弃一次多余的机会也不是很明智。

因此我的想法是：当知道 \(x\) 的范围只有两个数的时候，直接把这两个数猜一遍就可以了。那么我们提问的最终目标从将 \(x\) 锁定成一个数弱化成了锁定成两个数的一个小范围。

---

对交互的询问进行分析，我们考虑交互库不骗人的时候怎么做。

我们大概能知道这种交互问题都是不断缩小 \(x\) 可能的范围得到答案的，不妨放称当前 \(x\) 可能的范围为“目标范围”，最开始目标范围就是 \([1, n]\) 的正整数全集，而我们的目标就是把目标范围减少到大小为 \(2\)。为了确保询问次数低于限制参数，我们期望每次能让目标范围降低的尽可能多。

这里让目标范围降低多少的计算，应该按照交互库的 Yes，No 两种回答中，能让目标范围降低地最少的那个来计算，也即我们要按照最坏情况考虑。

比如当前的目标范围是 \(U\)，你提问一次 \(S = \{1\}\)(我们先暂且假定交互库不骗人)，那么交互库回答 Yes，不管 \(U\) 多大都能降低成 \(1\)，也即 \(U\) 的大小会降低 \(|U| - 1\)。这个降低效果没人敢说不高。但是如果交互库回答 No，目标范围大小只能降低 \(1\)，这就很不优秀了。根据按照最坏情况考虑的原则，这种询问策略的目标范围降低效果为降低 \(1\)，明显不是我们想要的策略。

提一嘴，这里交互库自适应，所以要按照最坏情况考虑；但如果交互库不自适应，那么可能可以有正确率不是 \(100\%\) 但是可以很高的交互策略：可以算一下交互库回答两种答案的期望，从而得到目标范围降低的期望，而不是最坏情况。

如果一个交互策略的最坏情况很不优秀，但是期望比较优秀，在交互库不自适应的情况下可能也是可以做的。这是后话了。

---

如果交互库不骗人，策略还是比较容易想到的，折半查找即可。

设当前目标范围是 \(U\)，我们取 \(U\) 的一个大小为 \(\left\lfloor\dfrac{|U|}2\right\rfloor\) 的子集 \(S\) 进行提问。如果回答 Yes，那么目标范围 \(U \gets S\)，大小变成 \(\left\lfloor\dfrac{|U|}2\right\rfloor\)，也即降低 \(\left\lceil\dfrac{|U|}2\right\rceil\)；如果回答 No，目标范围 \(U \gets \complement_US\)，大小变成 \(\left\lceil\dfrac{|U|}2\right\rceil\)，也即降低 \(\left\lfloor\dfrac{|U|}2\right\rfloor\)。

那么这种策略，每次可以将目标范围 \(U\) 大小降低 \(\left\lfloor\dfrac{|U|}2\right\rfloor\)，我们可以在 \(\log_2n\) 的询问次数解决问题。

---

如果交互库骗人呢？

首先我们要分析清楚的是，会骗人的交互库对于我们询问的回答，能给我们提供什么确定的信息。容易看出，在交互库骗人时，单独一次询问的回答什么信息都不能提供，如果我们只看不相邻的两次询问，也什么信息都不能提供。关键就是在于我们要利用好相邻两次询问最少有一次是真的，来看 相邻的两次询问能带来什么信息。

不过，在分析这个之前，我先介绍一个关键的思想：对于一次 \(S\) 的询问：

• 交互器回答 Yes：说明本轮交互器告诉我们 \(x\) 在 \(S\) 中。
• 交互器回答 No：说明本轮交互器告诉我们 \(x\) 在 \(\complement_US\) 中。

请注意这里对回答 No 的思考方式，我们不要直接思考 \(x\) 不在 \(S\) 中，这样会越思考越乱。正确想法应该是：对于一次 \(\boldsymbol S\) 的询问，无论交互器的回答是什么，它提供我们的信息都是 \(\boldsymbol x\) 在某个集合 \(\boldsymbol{S'}\) 里，只是回答 Yes 代表 \(S' = S\)，回答 No 代表 \(S' = \complement_US\)。这个想法的改变对于解题非常有帮助，后面大家会深刻感受到这点。

现在来看相邻的两次询问能带来什么信息。假设我们先询问一次，得到了 \(x \in S'\)(注意，根据上面的思想转变，这里 \(x \in S'\) 已经同时蕴含了交互器的两种回答)，再询问一次，得到了 \(x \in T'\)，我们能得到什么信息？

这两次询问的结果在交互库不骗人时，保证均是真的，我们可以得到 \(x \in S’\) 且 \(x \in T'\) 为真，即 \(x \in S’ \cap T'\)。

而在交互库骗人时，这两条信息的真假并不确定，只保证至少有一个是真的，即：\(x \in S'\) 或 \(x \in T'\) 为真。这样我们得到的信息是 \(x \in S' \cup T'\)。请记住这个结论： 本题中相邻的两次反馈为 \(\boldsymbol{x \in {S'}}\) 和 \(\boldsymbol{x \in {T'}}\) 的询问，得到的确定性信息为 \(\boldsymbol{x \in {S' \cup T'}}\)。这个结论尤为重要，是本题根据询问回答推出确定信息的基本方法。

总结一下：通过两次相邻的，反馈分别为 \(x \in S'\) 和 \(x \in T'\) 的两次询问，可确定 \(x \in S' \cup T'\)，将目标范围 \(U\) 缩小到 \(S’ \cup T'\)，换句话说，\(\complement_U(S' \cup T') = \complement_US' \cap \complement_UT'\) 可以从全集中被删除了。

回想我们的目标，我们期望用这两次相邻的询问，让目标范围降低地尽可能多。

先梳理思路：\(S'\) 和 \(T'\) 是由你的询问和交互器共同决定的，如果你决定做两次 \(S\) 和 \(T\) 的询问，交互器对这两种询问可能有四种不同的回答，而你显然无法事先预知交互器的回答，并且交互库自适应，所以 \(S' = S\) 或 \(S' = \complement_US\)，\(T' = T\) 或 \(T' = \complement_UT\) 组成的共四种可能中，你需要按照最坏情况作为“先问 \(S\)，再问 \(T\)”的目标范围缩小效果。然后，再探求什么样的 \(S\) 和 \(T\) 能使得这个目标范围缩小效果达到最高。

还是假设当前目标范围为 \(U\)，连续两次分别询问了 \(S\) 和 \(T\)，那么：

• 两次均回答 Yes，可以将目标范围进一步锁定到 \(S \cup T\)，也即 \(\complement_U\left(S \cup T\right) = \complement_U S \cap \complement_U T\) 可以被删去。
• 第一次回答 No，第二次回答 Yes，可以将目标范围进一步锁定到 \(\complement_U S \cup T\)，也即 \(\complement_U\left(\complement_U S \cup T\right) = S \cap \complement_UT\) 可以被删去。
• 第一次回答 Yes，第二次回答 No，可以将目标范围进一步锁定到 \(S \cup \complement_UT\)，也即 \(\complement_U\left(S \cup \complement_UT\right) = \complement_US \cap T\) 可以被删去。
• 两次均回答 No，可以将目标范围进一步锁定到 \(\complement_US \cup \complement_UT\)，也即 \(\complement_U\left(\complement_US \cup \complement_UT\right) = S \cap T\) 可以被删去。

上面的等号用的是德摩根定律化简，读者处理集合问题应当熟练应用。

这里我们应该按照最坏情况讨论，即如果我们钦定询问第一次询问 \(S\)，第二次询问 \(T\)：

• 最坏情况下，目标范围的大小至少会缩小到 \(\max\left(\left|S \cup T\right|, \left|\complement_U S \cup T\right|, \left|S \cup \complement_UT\right|, \left|\complement_US \cup \complement_UT\right|\right)\)。
• 最坏情况下，目标范围的大小至少会减少 \(\min\left(\left|S \cap T\right|, \left|\complement_U S \cap T\right|, \left|S \cap \complement_UT\right|, \left|\complement_US \cap \complement_UT\right|\right)\)。

当然，上面两条是等价的，这里我选择第二条处理(选第一条处理也很好做，读者可以自行尝试)。

我们的目标是最大化缩小效果，也即选定 \(S\) 和 \(T\)，最大化 \(\min\left(\left|S \cap T\right|, \left|\complement_U S \cap T\right|, \left|S \cap \complement_UT\right|, \left|\complement_US \cap \complement_UT\right|\right)\)。

对于集合问题我们可以考虑绘制韦恩图。

设上面黄色区域代表的集合为 \(S_1\)，大小为 \(a\)；紫色区域代表的集合为 \(S_2\)，大小为 \(b\)；棕色区域代表的集合为 \(S_3\)，大小为 \(c\)；白色区域代表的集合为 \(S_4\)，大小为 \(d\)。

容易发现，\(S_1\)，\(S_2\)，\(S_3\)，\(S_4\) 互不相交，并集为 \(U\)，即 \(a +b +c + d = |U|\)。

观察目标最值的四项：\(\min\left(\left|S \cap T\right|, \left|\complement_U S \cap T\right|, \left|S \cap \complement_UT\right|, \left|\complement_US \cap \complement_UT\right|\right)\)。

我们可以发现，\(S_1 = S \cap \complement_UT\)，\(S_2 = \complement_US \cap T\)，\(S_3 = S \cap T\)，\(S_4 = \complement_US \cap \complement_UT\)，也即目标最值中的四项恰好和韦恩图中的四个小区域是完全对应的。

那么目标最值其实就是 \(\min(a, b, c, d)\)，我们期望它最大。

\(a\)，\(b\)，\(c\)，\(d\) 作为和为 \(|U|\) 的正整数，它们的最小值最大就是 \(\left\lfloor\dfrac{|U|}4\right\rfloor\)。构造也比较简单，先令 \(a = b = c = d = \left\lfloor\dfrac{|U|}4\right\rfloor\)，此时 \(a +b +c +d\) 距离 \(|U|\) 还剩 \(|U| \bmod 4\)，将 \(|U| \bmod 4\) 随意地加在这四个数中即可。

目标最值已求出，那么我们将 \(U\) 尽可能平均分为四个子集 \(S_1\)，\(S_2\)，\(S_3\)，\(S_4\)(最小的子集大小为 \(\left\lfloor\dfrac{|U|}4\right\rfloor\) 即视作完成平均分)，然后令 \(S = S_1 \cup S_3\)，\(T = S_2 \cup S_3\)，这样就构造出了一组可以让目标集合 \(U\) 最坏情况下也至少减少 \(\left\lfloor\dfrac{|U|}4\right\rfloor\) 的询问策略。

回顾我们的构造方案，事实上，我们是将 \(U\) 分成了四个集合，然后选取了一种询问策略，使得无论回答如何，我们总能将四个集合之一扔出目标集合。并且这四个集合中最小的那个也至少有四分之一，使得最坏情况下我们总能将目标集合减少四分之一。

现在我们检验这样的询问策略能否达成目标。写程序判断需要用多少询问才能把目标集合大小缩小到 \(2\) 以内(别忘了我们有两次猜测机会)：

int main() {
    int n = (int)1e5;
	for (int i = 0; i <= 83; i += 2, n - (n >> 2))
		std :: cout << i << ' ' << n << std :: endl;
	return 0;
}

我们发现用 \(76\) 次询问即可让目标集合的大小降至 \(3\)，似乎下降的速度还可以，但后面无论使用多少次询问目标集合大小仍然是 \(3\)，想一下为什么。

其实很简单，我们每次能让目标集合减少 \(\left\lfloor\dfrac{|U|}4\right\rfloor\)，然而 \(|U| = 3\) 的时候这个值是 \(0\)，也就是压根无法减少。

分析原因，其实是因为 \(|U| = 3\) 的时候，不妨设 \(U = \{p, q, r\}\)，我们将其划分成四个子集，发现其中必须有一个是空的。这意味着我们的询问可能有一种回答，对目标集合的变化是：从 \(U\) 里扔掉了一个空集。这是无法化简问题的。

更具体来说，假设我们的划分是 \(S_1 = \{p\}\)，\(S_2 = \{q\}\)，\(S_3 = \{r\}\)，\(S_4 = \varnothing\)，问题为 \(S = S_1 \cup S_3\)，\(T = S_2 \cup S_3\)。那么在 \(S\) 和 \(T\) 均回答 Yes 时，我们的推论是目标集合变小到 \(S \cup T\)，也即扔掉了 \(S_4\)，这相当于什么也没扔。

或者假设划分是 \(S_1 = \{p\}\)，\(S_2 = \{q\}\)，\(S_3 = \varnothing\)，\(S_4 = \{r\}\)，问题为 \(S = S_1 \cup S_3\)，\(T = S_2 \cup S_3\)。那么在 \(S\) 和 \(T\) 均回答 No 时，我们的推论是目标集合变小到 \(\complement_US \cap \complement_UT\)，也即扔掉了 \(S_3\)，也造成了扔空集。

那么我们只能换一种策略了。既然 \(76\) 次询问就能让目标集合大小减少到 \(3\)，我们还有 \(6\) 次询问机会让它的大小减少到 \(2\)。

这里你可以尝试手玩一下(笔者其实手玩花了不少时间)。这里提供一种 \(3\) 次询问解决问题的策略：

先问一次 \(\{p\}\)，如果是 No，再问一次 \(\{p\}\)，如果还是 No，那么目标集合可缩减到 \(\{q, r\}\)。

否则，上一个状态应该是问了一次 \(\{p\}\) 得到了一个 Yes。然后直接问 \(\{q\}\) 即可。回答 Yes 目标集合为 \(\{p, q\}\)，否则为 \(\{p, r\}\)。

其实这个策略是可以推广的，上面的 \(p\)，\(q\)，\(r\) 换成集合，我们就得到了一种使用 \(3\) 个问题让目标集合大小减少 \(\left\lfloor\dfrac{|U|}3\right\rfloor\) 的做法。事实上这个减少速率是比使用 \(2\) 个问题让目标集合大小减少 \(\left\lfloor\dfrac{|U|}4\right\rfloor\) 要慢的，最坏需要 \(84\) 次询问才能让目标集合降低到 \(2\) 以内，不过这题好像没卡这个做法。

于是，我们使用了不多于 \(79\) 次询问解决了本题。

#include <bits/stdc++.h>
inline int read() {} // 读入数字的函数，省略
inline std :: string rest() {} // 读入字符串的函数，省略

inline bool query(std :: vector <int> v) {
	printf("? %d ", (int)v.size());
	for (int x : v)
		printf("%d ", x);
	puts("");
	fflush(stdout);
	return (rest() == " YES");
}

inline void solve(std :: vector <int> v) {
	int n = (int)v.size();
	if (n <= 2) {
		for (int x : v) {
			printf("! %d\n", x);
			fflush(stdout);
			if (rest() == " :)")
				exit(0);
		}
	} else if (n == 3) {
		if (!query({v[0]}) && !query({v[0]})) {
			solve({v[1], v[2]});
		} else if (query({v[1]})) {
			solve({v[0], v[1]});
		} else
			solve({v[0], v[2]});
	} else {
		std :: vector <int> S;
		std :: vector <int> T;
		for (int i = 0; i < n; ++i) {
			if (i & 1)
				S.push_back(v[i]);
			if (i & 2)
				T.push_back(v[i]);
		}
		std :: vector <int> nxt;
		int s = query(S) ? 1 : 0, t = query(T) ? 2 : 0;
		for (int i = 0; i < n; ++i)
			if (((i & 1) == s) || ((i & 2) == t))
				nxt.push_back(v[i]);
		solve(nxt);
	}
}

int main() {
	int n = read();
	std :: vector <int> v;
	for (int i = 1; i <= n; ++i)
		v.push_back(i);
	solve(v);
	return 0;
}

E2 Hard Version

在 Hard Version 中，限制参数 \(Q = 53\)。

观察我们刚才的询问策略哪里可以优化。我们从全局上查看刚才的询问策略，发现第一次询问和第二次询问是一组；第三次询问和第四次询问是一组；第五次询问和第六次询问是一组。每一组询问，我们将目标范围缩小。

然而这样“相邻两个询问必有一真”这个条件只在一组询问中的两个询问被用到；而上一组的最后一个询问和下一组的第一个询问也是相邻的，这两个询问之间也是有条件的，但我们没用到，造成了条件的浪费。

现在我们考虑怎么让每两个相邻询问的限制都用上。

一般地，假设当前的目标范围为 \(U\)，上一次询问交互库告诉我们 \(x\) 在 \(T\) 中，我们探求这次该怎么问。

很明显，我们问的集合一定是 \(U\) 的子集，并且一部分(可空)在 \(T\) 中，一部分(可空)在 \(\complement_UT\) 中。这里设 \(F = \complement_UT\)，并且询问集合在 \(T\) 中的部分为 \(T_0\)，在 \(F\) 中的部分为 \(F_0\)，即这次问的集合为 \(T_0 \cup F_0\)。并设 \(T_1 = T \setminus T_0\)，\(F_1 = F \setminus F_0\)。

如果这次的回答是 Yes，即这次询问交互库告诉我们 \(x\) 在 \(T_0 \cup F_0\) 中，我们可以确认 \(x\) 在 \(T \cup (T_0 \cup F_0) = T \cup F_0\) 中，因此目标集合 \(U \gets T \cup F_0\)，\(F_1\) 被丢出目标集合。同时，\(T \gets T_0 \cup F_0\)，以便下一次询问知道上一次询问交互库告知的信息。

如果这次的回答是 No，即这次询问交互库告诉我们 \(x\) 在 \(T_1 \cup F_1\) 中，可以确认 \(x\) 在 \(T \cup (T_1 \cup F_1) = T \cup F_1\) 中，\(U \gets T \cup F_1\)，\(F_0\) 被丢出目标集合，同时 \(T \gets T_1 \cup F_1\)。

这是一个类似 dp 的转移，考虑设计状态 \(f(U, T)\) 表示当前全集为 \(U\)，上一次询问交互库告诉我们 \(x \in T\) 时，最少的询问次数。这样并无问题，然而 \(F = U \setminus T\) 和其子集的信息在转移中大量用到，\(U\) 反而不怎么用到，如果每次表示 \(F\) 和其子集都要用 \(U \setminus T\) 来做中间桥梁，不是很直观。

因为 \(F\)，\(U\)，\(T\) 显然知二求一，不妨设 \(f(T, F)\) 表示上一次询问交互库告诉我们 \(x \in T\) 中，且 \(F = U \setminus T\) 时，最少的询问次数。

这样以来我们还要得知 \(F\) 转移时的变化，简单推理一下：

• 回答是 Yes，则 \(U \gets T \cup F_0\)，\(T \gets T_0 \cup F_0\)，\(F\) 仍应该是新的 \(U\) 和 \(T\) 的差集，并且 \(T \cup F_0\)，\(T_0 \cup F_0\) 中的并集都是两个不交集合的并，所以 \(F \gets T \setminus T_0\)，即 \(F \gets T_1\)。
• 回答是 No，则 \(U \gets T \cup F_1\)，\(T \gets T_1 \cup F_1\)，所以 \(F \gets T \setminus T_1\)。即 \(F \gets T_0\)。

于是我们可以写出转移方程：

\[f(T, F) = 1 + \min_{T_0 \subseteq T, F_0 \subseteq F} \max(f(T_0 \cup F_0, T_1), f(T_1 \cup F_1, T_0)) \]

这里 \(\min\) 的含义是：在当前 \((T, F)\) 这个状态下，我们可以且仅可以在 \(T\) 中选出子集 \(T_0\)，以及在 \(F\) 中选出子集 \(F_0\) 来询问。在不同的询问方式中，我们期望一个能让接下来的步数最小的询问方式来询问。

这里 \(\max\) 的含义是：在我们决定问 \(T_0 \cup F_0\) 后，交互库会返回 Yes 和 No 两种情况。交互库返回什么是我们不可预测的，并且因为交互库的自适应性，我们必须按照最坏的一种情况考虑。也即，对于 \(T_0 \cup F_0\) 的询问集合，它的后继询问步数应该取本次询问回答 Yes 和本次询问回答 No 后，两个后继询问步数的最大值。

边界状态是：\(|T \cup F| \le 2\) 时，\(f(T, F) = 0\)。

询问的方式是：在当前 \((T, F)\) 的状态下，考虑能让这个 \(\min\) 取到最小值的一对 \((T_0, F_0)\)，然后询问 \(T_0 \cup F_0\) 即可。

可以认为在第一次询问之前，交互器告诉了我们 \(x \in \{1, 2, \ldots, n\}\) 整个全集，因此初始状态是 \((\{1, 2, \ldots, n\}, \varnothing)\)。

然而这样的状态本身的复杂度就能达到 \(4^n\) 量级，显然无法承受。观察到，我们的询问策略显然和 \(T\) 和 \(F\) 这两个集合的具体形态没什么关系，只和它们的大小有关。也即，对于 \(|T_1| = |T_2|\)，\(|F_1| = |F_2|\)，我们有 \(f(T_1, F_1) = f(T_2, F_2)\)。

因此，我们考虑不将集合设入状态，而是将集合的大小设入状态。于是我们可以得到如下转移方程：

\[f(a, b) = 1 + \min_{0 \le c \le a, 0 \le d \le b}\max(f(c + d, a - c), f(a +b - c - d, c)) \]

边界状态是：\(a + b \le 2\) 时，\(f(a, b) = 0\)。

询问的方式是，在当前 \((T, F)\) 的状态下，考虑 \(a = |T|\)，\(b = |F|\)，以及能让 \(f(a, b)\) 这个 \(\min\) 取到最小值的一对 \((c, d)\)，然后在 \(T\) 中随便选一个大小为 \(c\) 的子集 \(T_0\)，\(F\) 中随便选一个大小为 \(d\) 的子集 \(F_0\)，询问 \(T_0 \cup F_0\) 即可。

初始状态是 \(f(n, 0)\)。

观察转移的顺序并检查转移的无环性：对于任意 \(f(a, b)\)，为了转移计算它的值用到的 \(f(a', b')\) 一定满足 \(c + d \le a + b\)，因为每次询问后目标全集一定没有变大。为验证，计算一下 \(f(c+ d, a - c)\) 中两个维上值的和 \(a + d\)，以及 \(f(a +b - c - d, c)\) 中两个维上值的和 \(a + b - d\)，它们确实不会超过 \(a + b\)。所以，我们的转移大体顺序一定是先转移并计算 \(a + b\) 小的 \(f(a, b)\)。

那么对于 \(a + b = a' + b'\)，\(f(a, b)\) 和 \(f(a, b')\) 应该先转移谁？考虑到如果我们花费了一次提问，使得当前的全集 \(T \cup F\) 没有增加，但是 \(F\) 反而变少了，这样是一定不优的。因为每次我们都是在 \(F\) 中选择一个子集抛出全集，因此我们当然希望 \(F\) 尽可能大，从而使得能选择抛出全集的 \(F\) 的子集尽量大。因此对于 \(a + b = a' + b'\)，不妨令 \(b > b'\)，我们应该令 \(f(a, b)\) 去转移 \(f(a',b')\)(\(f(a', b')\) 要比 \(f(a, b)\) 后转移到)。

事实上，\(f(a, b)\) 若用到 \(a' +b' = a + b\) 的 \(f(a', b')\) 转移，意味着 \(d = 0\) 或 \(d = b\)，也就是我们选择的 \(F_0 = \varnothing\) 或 \(F_0 = F\)(即 \(F_1 = \varnothing\))，这均会导致计算分别扔掉 \(F_0\)，\(F_1\) 时至少有一种丢了空集，也即目标集合大小不变。

至于 \(f(a, b)\) 转移用到自己的情况，意味着最坏情况下这次询问可能会让 \((F, T)\) 毫无变化，显然这样的询问是浪费的，不可取，直接不转移即可(其实不用特殊处理，因为 \(f(a, b) + 1\) 一定无法作为更小的值更新 \(f(a, b)\))。

以 \(a + b\) 升序为第一优先级，\(b\) 降序为第二优先级，这样转移是一定无环的，转移顺序就解决了。

考虑到上面的状态复杂度为 \(n^2\)，转移时间复杂度为 \(\Theta(n^4)\)，显然无法承受。怎么办？

这里有一种启发式的思想，不妨从 E1 尽可能让全集大小降速更快的角度思考转移的过程。

当前的状态是 \((T, F)\)，每次我们选定 \(T_0 \cup F_0\)，根据上面的讨论，交互库回答 Yes 时，状态变为 \((T_0 \cup F_0,T_1)\)，\(F_0\) 被丢出集合；否则变为 \((T_1 \cup F_1, T_0)\)，\(F_1\) 被丢出集合。我们希望最坏情况下被丢的尽可能多，所以令 \(\min(|F_0|, |F_1|)\) 取最大，让 \(F_0\) 均分 \(F\) 比较合适。而且我们还希望最坏情况下，下次的 \(F\) 也能尽量大(这样下一次丢的 \(F_0\) 或 \(F_1\) 也能尽量大)所以令 \(\min(|T_0|, |T_1|)\) 最大，还是让 \(T_0\) 均分 \(T\) 比较合适。

因此，我们考虑让转移方程中的 \(c\) 和 \(d\) 只在 \(\dfrac a 2\) 和 \(\dfrac b 2\) 附近几个整数枚举，这样以来枚举复杂度就会降低成 \(\Theta(n^2)\)。这样以来 \(f(a, b)\) 的内容可能不再是最少步数，但经试验，它的内容也是一个相对较少的步数(只不过不是最优解而已)。本题中，我们并不关心最优步数的具体精确值，只需要得到一个足够少步数的方案，所以这样是可行的。

这里我取 \(c \in \left[\left\lfloor\dfrac{a - 1}2\right\rfloor, \left\lceil\dfrac{a}{2} \right\rceil + 1\right]\)，\(d \in \left[\left\lfloor\dfrac{b - 1}2\right\rfloor, \left\lceil\dfrac b 2 \right\rceil + 1\right]\)。

然而 \(n^2\) 还是过不了 \(10^5\)。我们不妨再次启发式一下，真的需要用到所有状态吗？如果我们只想知道 \(f(n, 0)\) 的值，实际需要的状态数是不是会少于 \(n^2\)，乃至于可以接受呢？我们可以用记忆化搜索进行尝试。

typedef std :: pair <int, int> pii;
std :: map <pii, int> f;
std :: map <pii, pii> g;

inline int F(int a, int b) {
	if (a + b <= 2)
		return 0;
	if (f.count({a, b}))
		return f[{a, b}];
	int ans = 1000, ansc = -1, ansd = -1;
	for (int c = std :: max(0, (a - 1) >> 1); c <= std :: min(a, (a + 3) >> 1); ++c)
		for (int d = std :: max(0, (b - 1) >> 1); d <= std :: min(b, (b + 3) >> 1); ++d) {
			if ((c + d) + (a - c) == a + b && a - c <= b)
				continue;
			if ((a + b - c - d) + c == a + b && c <= b)
				continue;
            // 上面两行是为了控制 a + b = a' + b' 时的转移顺序
            // 注意 a - c <= b, c <= b 的等号不能省略，这是为了防止 F(a, b) 的求解访问自身导致死递归
			int now = 1 + std :: max(F(c + d, a - c), F(a + b - c - d, c));
			if (now < ans) {
				ans = now;
				ansc = c;
				ansd = d;
			}
		}
	g[{a, b}] = {ansc, ansd};
	return f[{a, b}] = ans;
}

调用 F(1e5, 0) 我们可以发现，这样运行后 \(f\) 的大小为 \(3947\)，这个状态数无疑是十分优秀的。

注意到初始时我们应该调用 \(F(n, 0)\) 而非 \(F(10^5, 0)\)，这是因为 \(F(10^5, 0)\) 访问到的所有状态可能不含有 \(F(n, 0)\) 所需的状态。另外，\(F(n, 0)\) 并不是 \(n\) 越大状态数越多，比如 \(F(10^5 - 3, 0)\) 访问到的状态数为 \(3953\)。然而，\(n\) 越大状态数确实呈现越多的趋势，不可能 \(n\) 变小时状态数突然暴涨，因此我们可以推断 \(F(n, 0)\) 的状态数大概就是 \(4000\) 的量级。

而且 \(f(10^5, 0)\) 恰好为 \(53\)，恰好满足要求，至此本题解决。

由于本题过于启发式，时间复杂度笔者写不出来。

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2023-06-20 19:58:38 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2023-06-20 21:59:36
 */
#include <bits/stdc++.h>
inline int read() {
	int x = 0;
	bool f = true;
	char ch = getchar();
	for (; !isdigit(ch); ch = getchar())
		if (ch == '-')
			f = false;
	for (; isdigit(ch); ch = getchar())
		x = (x << 1) + (x << 3) + ch - '0';
	return f ? x : (~(x - 1));
}
inline std :: string rest(bool space = true) {
	std :: string s;
	char ch = getchar();
	for (; !isgraph(ch); ch = getchar());
	for (; isgraph(ch); ch = getchar())
		s.push_back(ch);
	return space ? (" " + s) : s;
}

typedef std :: pair <int, int> pii;
std :: map <pii, int> f;
std :: map <pii, pii> g;

inline int F(int a, int b) {
	if (a + b <= 2)
		return 0;
	if (f.count({a, b}))
		return f[{a, b}];
	int ans = 1000, ansc = -1, ansd = -1;
	for (int c = std :: max(0, (a - 1) >> 1); c <= std :: min(a, (a + 3) >> 1); ++c)
		for (int d = std :: max(0, (b - 1) >> 1); d <= std :: min(b, (b + 3) >> 1); ++d) {
			if ((c + d) + (a - c) == a + b && a - c <= b)
				continue;
			if ((a + b - c - d) + c == a + b && c <= b)
				continue;
			int now = 1 + std :: max(F(c + d, a - c), F(a + b - c - d, c));
			if (now < ans) {
				ans = now;
				ansc = c;
				ansd = d;
			}
		}
	g[{a, b}] = {ansc, ansd};
	return f[{a, b}] = ans;
}

inline bool ask(std :: basic_string <int> S) {
	printf("? %d ", (int)S.size());
	for (int x : S)
		printf("%d ", x);
	puts("");
	fflush(stdout);
	return (rest() == " YES");
}

inline void solve(std :: basic_string <int> T, std :: basic_string <int> F) {
	int a = (int)T.size(), b = (int)F.size();
	if (a + b <= 2) {
		std :: basic_string <int> ans = T + F;
		for (int x : ans) {
			printf("! %d\n", x);
			fflush(stdout);
			if (rest() == " :)")
				exit(0);
		}
	} else {
		auto p = g[{a, b}];
		int c = p.first, d = p.second;
		std :: basic_string <int> T0, T1, F0, F1;
		T0.assign(T.begin(), T.begin() + c);
		T1.assign(T.begin() + c, T.end());
		F0.assign(F.begin(), F.begin() + d);
		F1.assign(F.begin() + d, F.end());

		if (ask(T0 + F0))
			solve(T0 + F0, T1);
		else
			solve(T1 + F1, T0);
	}
}

int main() {
	int n = read();
	F(n, 0);
	std :: basic_string <int> S;
	S.resize(n);
	std :: iota(S.begin(), S.end(), 1);
	solve(S, {});
	return 0;
}