Solution -「ROI 2018」「LOJ #2850」无进位加法
\(\mathscr{Description}\)
Link.
给定 \(\{a_n\}\)，每次令某个 \(a_i\leftarrow a_i+1\)，最终得到 \(\{b_n\}\)，求 \(\sum b=\bigoplus b\) 时 \(\sum b\) 的最小值。
\(n,\sum\lceil\log_2a_i\rceil\le3\times10^5\)。
\(\mathscr{Solution}\)
很有贪心的味道，我们从 \(a_i=2^{k_i}\) 的情况入手分析。在这一情况下，贪心是平凡的：从低到高扫 bit，当前 bit 最多留一个数，其他的进位。考察此时答案的最高 bit \(h\)，可以发现，当 \(\{a_i\}\) 降序排列时，有 \(h=\max_{i=1}^n\{k_i+i-1\}\)。必要性显然，归纳可证充分。
同时，注意到一种简单的规约方式：若 \(a_i\in[2^{k_i},2^{k_i+1})\)，令所有 \(a_i\) 二进制上取整，规约到上面这种情况，此时答案的最高 bit 为 \(h+1\)。因此我们可以得到一个思路：求出 \(h\)，判断答案最高 bit 能否为 \(h\)。
判断最高 bit？暴力一点，直接搜。设 \(p=\min\arg\max_{i=1}^n\{k_i+i-1\}\)，那么答案 \([h-p+2,h]\) 里的 bit 全为 \(1\)（它们把 \([1,p)\) 里的数一一抬走，这些数也应当被删掉），如果 \(h\) 不行，那 \(p\) 就必然被 \(h+1\) 抬走；否则 \(h-p+1\) 可以让 \(a_p\) 变小但无法把它抬走（它是 \(\arg\max\)），怎么办？直接将 \(a_p-2^{h-p+1}\)，也即是 \(a_p\) 丢到最高位得到的 \(a_p'\)，放回集合里，递归判断最高 bit 能否为 \(h-p\)。
实现上，每个数以 \(1\) 位最高 bit 的后缀才可能被加入 \(\{a_n\}\)，所以可以在外部对所有这样的后缀基排，把 \(x\) 加入集合时，在线段树 \(x\) “绝对排名”的位置上做修改。由于线段树只是拿来维护 \(\max\) 和 \(\arg\max\)，所以当前不在集合里的数对应排名位置上的值设成极小就好。
然后——既然你发现我都在将实现了——设 \(L=\sum\lceil\log_2a_i\rceil\)，我们宣称这个算法的复杂度是 \(\mathcal O((n+L)\log L)\) 的，直接写就完啦。
证明
考虑搜索过程，由于最后能得到答案，所以必然有 $\mathcal O(n)$ 次成功的递归，这部分复杂度是 $\mathcal O(n\log L)$。关键是回溯的复杂度，在此先描述一下具体一点的算法流程。对于当前的 \(h\)，若不能直接选，我们将尝试 \(h+1\)。若 \(h+1\) 已经超过了要求的答案上界，就需要把 \([1,p)\) 里的数全部加回来；否则 \(h+1\) 一旦出手，必然出解（已经选出理论上界了），不用回溯。
对着代码进行神妙观察， 我们发现：每个回溯的 \(x\) 都唯一对应这答案里一个确定为 \(1\) 的 bit（来自上文“……里的 bit 全为 \(1\)” 那句话），答案 bit 数显然不超过 \(\mathcal O((n+L)\log L)\)！因此，回溯的总复杂度为 \(\mathcal O((n+L)\log L)\)，算法复杂度亦为此。 \(\square\)
\(\mathscr{Code}\)
/*+Rainybunny+*/
#include <bits/stdc++.h>
#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)
typedef std::pair<int, int> PII;
#define fi first
#define se second
const int MAXN = 3e5, IINF = 0x3f3f3f3f;
int n, mxl, tot, low[MAXN + 5], ord[MAXN + 5];
std::vector<int> dgt[MAXN + 5], rnk[MAXN + 5], own[MAXN + 5];
PII ref[MAXN + 5];
std::set<int> alv;
bool ans[MAXN * 2 + 5];
struct SegmentTree {
PII mx[MAXN << 2];
int tag[MAXN << 2];
inline void pushup(const int u) {
mx[u] = std::max(mx[u << 1], mx[u << 1 | 1]);
}
inline void pushad(const int u, const int k) {
mx[u].fi += k, tag[u] += k;
}
inline void pushdn(const int u) {
if (tag[u]) {
pushad(u << 1, tag[u]), pushad(u << 1 | 1, tag[u]);
tag[u] = 0;
}
}
inline void build(const int u, const int l, const int r) {
mx[u] = { -IINF, l };
if (l == r) return ;
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}
inline void modify(const int u, const int l, const int r,
const int ml, const int mr, const int k) {
if (ml > mr) return ;
if (ml <= l && r <= mr) return pushad(u, k);
int mid = l + r >> 1; pushdn(u);
if (ml <= mid) modify(u << 1, l, mid, ml, mr, k);
if (mid < mr) modify(u << 1 | 1, mid + 1, r, ml, mr, k);
pushup(u);
}
} sgt;
inline void update(const int rk, const int type) {
if (~type) alv.insert(rk);
else alv.erase(rk);
sgt.modify(1, 1, tot, rk, rk, type * (IINF + dgt[ref[rk].fi][ref[rk].se]));
sgt.modify(1, 1, tot, 1, rk - 1, type);
}
inline bool solve(const int lim) {
if (sgt.mx[1].fi < 0) return true;
if (sgt.mx[1].fi >= lim) return false;
int tar = sgt.mx[1].fi, rk = sgt.mx[1].se; PII id = ref[rk];
update(rk, -1);
if (id.se) update(rnk[id.fi][id.se - 1], 1);
std::vector<int> back;
while (alv.size() && *alv.rbegin() > rk) {
back.push_back(*alv.rbegin()), update(*alv.rbegin(), -1);
}
rep (i, 0, back.size()) ans[tar - i] = true;
if (solve(tar - back.size())) return true;
ans[tar - back.size()] = false;
if (id.se) update(rnk[id.fi][id.se - 1], -1);
if (tar + 1 < lim) {
ans[tar + 1] = true;
assert(solve(tar - back.size() + 1));
return true;
} else {
update(rk, 1);
for (int u: back) update(u, 1);
return false;
}
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
rep (i, 1, n) {
static std::string str; std::cin >> str;
std::reverse(str.begin(), str.end());
int len = str.size(); mxl = std::max(mxl, len);
rep (j, 0, len - 1) if (str[j] == '1') {
dgt[i].push_back(j), own[j].push_back(i);
}
}
rep (i, 0, mxl - 1) {
ord[0] = 0;
for (int j: own[i]) ord[++ord[0]] = j;
std::sort(ord + 1, ord + ord[0] + 1,
[](const int u, const int v) { return low[u] < low[v]; });
rep (j, 1, ord[0]) {
rnk[ord[j]].push_back(low[ord[j]] = ++tot);
ref[tot] = { ord[j], rnk[ord[j]].size() - 1 };
}
}
sgt.build(1, 1, tot);
rep (i, 1, n) update(rnk[i].back(), 1);
assert(solve(IINF));
int fin = 0;
rep (i, 0, mxl + n + 1) if (ans[i]) fin = i;
per (i, fin, 0) std::cout << ans[i];
std::cout << '\n';
return 0;
}
