[ACNOI2022]猜数

题目

题目背景
“阿喏，” $\mathsf{OUYE}$ 忽然说，“我们结为兄弟吧！就是那个，作为条件的延伸。因为像我这样的弱者，不报团取暖就很令人生疑……”

$\mathsf{DD}(\mathsf{XYX})$ 颇吃了一惊。他没有想到事情会进行的这么顺利。

“那好，回家的路上顺便去拜把子吧！”

“只要内卷不止。” $\mathsf{OUYE}$ 想。

“只要红石不完。” $\mathsf{DD}(\mathsf{XYX})$ 想。

—— “便永不分离！” 二人齐声说。

题目描述
交互题。有一个 $x\in [10,2^{64}-10)$ 未知，你来猜。每次可以给出若干区间：

• 若 $x$ 在这些区间的并集当中，则交互库有 $p=0.8$ 的概率返回 $1$，有 $(1-p)$ 概率返回 $0$ 。
• 否则，交互库必然返回 $0$ 。

请你用期望最少的次数确定 $x$ 。

数据范围与提示
进行 $T=3000$ 次测试后，你的平均询问次数不应超过 $107$ 。

思路

希望你也有 $\mathsf{OUYE}$ 一样的慧眼，足以看出关键信息是 每个数成为答案的概率。

我们用 $\mathrm{Entropy}$ 衡量它，符号为 $H$ 。——你不知道信息熵？那你肯定没有看过 $3b1b$ 教你玩 $\mathrm{wordle}$ 🤔

---

突然发现我也不会信息熵，我是小丑。

定义式
$$H=-\sum _{x\in \mathbb{U}}\mathrm{Pr}(x){\log }_2\mathrm{Pr}(x)$$

其中 $\mathbb{U}$ 是样本空间。下文简记 $\omega (x)=-x{\log }_{2}x$ 。

这个定义非常符合我们的直觉：注意到 $\omega (ab)=b\omega (a)+a\omega (b)$，因此有
$$\begin{array}{rl}H& =\sum _{x\in \mathbb{U}}\omega (\mathrm{Pr}[x|A]\mathrm{Pr}(A))+\sum _{x\in \mathbb{U}}\omega (\mathrm{Pr}[x|\neg A]\mathrm{Pr}(\neg A))\\ & =\mathrm{Pr}(A)H[A]+\mathrm{Pr}(\neg A)H[\neg A]+\omega (\mathrm{Pr}(A))+\omega (\mathrm{Pr}(\neg A))\end{array}$$
其中 $H[A]$ 为 $A$ 条件下的熵，即 ${\sum }_{x\in \mathbb{U}}\omega (\mathrm{Pr}[x|A])$ 。

也就是说，用 $\mathrm{Pr}(A)$ 对应的熵（信息量）知晓 $A$ 是否成立，然后往下递归。

---

考虑询问一个集合 $T$ 满足 $\mathrm{Pr}[x\in T]=q,H[x\in T]=h_1,H[x\notin T]=h_0$ 。询问之后：

• 有 $pq$ 的概率得到 $1$，然后 $\mathrm{Pr}[x\in T]=1$，新的熵 $H=h_1$ 。
• 有 $(1-pq)$ 的概率得到 $0$，由贝叶斯公式 $\mathrm{Pr}[x\in T|0]=\frac{\mathrm{Pr}[0|x\in T]\mathrm{Pr}[x\in T]}{\mathrm{Pr}[0]}=\frac{q-pq}{1-pq}$，新的熵 $H=\frac{q-pq}{1-pq}{h}_1+\frac{1-q}{1-pq}{h}_2+\omega (\frac{q-pq}{1-pq})+\omega (\frac{1-q}{1-pq})$ 。

原本的熵是 $q{h}_1+(1-q)h_2+\omega (q)+\omega (1-q)$ 。因此，期望下得到的信息量是
$$\begin{array}{rl}\Delta H& =q{h}_1+(1-q)h_2+\omega (q)+\omega (1-q)-pq{h}_1\\ & -(1-pq)\left[\frac{q-pq}{1-pq}{h}_1+\frac{1-q}{1-pq}{h}_2+\omega \left(\frac{q-pq}{1-pq}\right)+\omega \left(\frac{1-q}{1-pq}\right)\right]\\ & =\omega (q)+\omega (1-q)-(1-pq)\left[\omega \left(\frac{q-pq}{1-pq}\right)+\omega \left(\frac{1-q}{1-pq}\right)\right]\end{array}$$
这也是符合我们的直观感受的——内部元素并没有获得区分，因此内部的熵并不会干扰信息量。

利用在线数学工具（考场上建议打表取最优值）可知最优的
$$q=\frac{5\left(5\sqrt{4000+3381\sqrt{5}}-100\sqrt{5}-64\right)}{2869}$$
它约等于
$$q\approx 0.4356636377796835808889$$
取 $q=0.435$ 计算，期望 $\Delta H\approx 0.618$ 。多么美丽的数字。因此期望下经过 $\frac{64}{\Delta H}\approx 103.56$ 次询问后可以出解。

代码

• 因为是期望询问次数，不能用尽 $107$ 次询问就收，而是出解就 $\mathtt{return}$ 。
• 由于数字多达 $2^{64}$ 个，过程中真实答案的 $\mathrm{Pr}$ 可能降到很低，请不要放弃它！
• 时间复杂度不太好算。但可以想到的是：区间数量是比较少的，约为 $64$ 个。

#include "guess.h"
#include <cstdio>
#include <algorithm> // Almighty XJX yyds!!!
#include <cstring>  // oracle: ZXY yydBUS!!!
#include <cctype> // Huge Egg Dog eats me!!!
#include <vector>
#include <utility>
#include <cmath>
using llong = long long;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
# define rep0(i,a,b) for(int i=(a); i!=(b); ++i)
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar()) if(c == '-') f = -f;
	for(; isdigit(c); c=getchar()) a = a*10+(c^48);
	return a*f;
}

using ullong = unsigned long long;
using PUU = std::pair<ullong,ullong>;
extern bool Query(std::vector<PUU> v);
bool query(std::vector<PUU> v){
	for(PUU &rg : v) -- rg.second;
	return Query(v); // close range
}

using ldb = long double;
using NODE = std::pair<PUU,ldb>;
bool cmp(const NODE &a, const NODE &b){
	return a.second/(a.first.second-a.first.first)
		> b.second/(b.first.second-b.first.first);
}
ullong Guess(){
	static const ullong MAXX = 18446744073709551606ull;
	std::vector<NODE> v; v.resize(1);
	v[0] = NODE{PUU{10,MAXX},1};
	const long double q = 0.435, p = 0.8, notp = 0.2;
	while(true){
		if(v[0].first.second == v[0].first.first+1
		  && int(v.size()) == 1) return v[0].first.first;
		std::vector<PUU> ask; ask.clear();
		long double nowq = 0;
		for(const NODE &rg : v){
			if(nowq >= q) break; // enough
			if(nowq+rg.second <= q){
				nowq += rg.second; // good
				ask.push_back(rg.first); continue;
			}
			ullong len = rg.first.second-rg.first.first;
			ullong cnt = ullong(floor((q-nowq)*len/rg.second));
			if(nowq == 0 && cnt == 0) cnt = 1;
			if(!cnt) continue; // length = 0
			nowq += cnt*rg.second/len; ask.push_back(
				PUU{rg.first.first,rg.first.first+cnt});
		}
		if(query(ask)){
			const int lenask = int(ask.size());
			for(int i=0,j=0,k=0; true; ++i){
				if(j == lenask){ v.resize(k); break; }
				if(ask[j] == v[i].first) // covered
					v[k] = v[i], v[k++].second /= nowq, ++ j;
				else if(ask[j].first == v[i].first.first){
					ullong nxt = ask[j].second-ask[j].first;
					ullong now = v[i].first.second-v[i].first.first;
					v[k++] = NODE{ask[j++],v[i].second/nowq*nxt/now};
				}
			}
		}
		else{
			long double wxk = 1-p*nowq;
			const int lenask = int(ask.size()), lenv = int(v.size());
			for(int i=0,j=0; i!=lenv; ++i){
				v[i].second /= wxk;
				if(j == lenask) continue;
				if(ask[j] == v[i].first)
					v[i].second *= notp, ++ j;
				else if(ask[j].first == v[i].first.first){
					ullong nxt = ask[j].second-ask[j].first;
					ullong now = v[i].first.second-v[i].first.first;
					v.push_back(NODE{ask[j],v[i].second*notp*nxt/now});
					v[i].first.first = ask[j++].second; // outside
					v[i].second = v[i].second*(now-nxt)/now;
				}
			}
		}
		if(true){ // will this be slow?
			std::sort(v.begin(),v.end(),cmp);
			long double tot = 0;
			for(const NODE &rg : v) tot += rg.second;
			for(NODE &rg : v) rg.second /= tot;
		}
	}
}