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;
}