2023 ICPC Xian

2023 ICPC Xian

ICPC Xian

也是非常坐牢的一场

E

从能力值小的人开始考虑，遍历他能胜利多少次，若他能胜利 \(x\) 次，则必须在交换操作后有一个长度为 \(2^x\) 的区间里面都是比他弱的，从小到大遍历胜利次数，同时维护区间：当下标是奇数时，区间向右拓展一倍，否则向左拓展一倍，比完一轮后，对下标除二向上取整。

I

若答案等于 \(g\)，则选择的三个数一定是 \(g\) 的倍数，并且在前两个数一定是相邻的 \(g\) 的倍数，即对于确定的 \(j\)，我们去找最大的 \(i\) 使得 \(i < j\) 并且 \(g | a_i\)，于是我们可以确定第三个数的的下标 \(k\) 在大于等于 \(2j - i\) 的地方，于是我们选择最小的 \(k\) 使得 \(2j - i \leq k\) 且 \(g | a_k\)，这样选出来的三个数，并不能包含所有的答案为 \(g\) 三元组，但是这样一定是最优的三元组，因为对于固定的中心 \(j\) 和答案 \(g\)，可能有若干符合条件的 \(i\) 和 \(k\)，但是我们选出来的 \(i\) 和 \(k\) 的距离是最小的，能被尽可能多的区间包含。

接下来就是求出这样的三元组：

我们从左到右枚举中间一个数，然后枚举它的因数作为答案 \(g\)，找上一个 \(g\) 的倍数作为第一个数，对于第 3 个数，我们现在只知道他最近在哪里，于是我们在那个最近的位置先留下前两个数的信息（第一个数的位置和答案 \(g\)）：

    for (int i = 1; i <= n; ++i) {
        std::cin >> a[i];
        mx = std::max(a[i], mx);

        // 枚举因数
        for (auto &f : fac[a[i]]) {
            if (lst[f] !=0) {
                // 记录信息
                info[std::min(2 * i - lst[f], n + 1)].push_back({ lst[f], f });
            }
            lst[f] = i;
        }
    }

再从右往左扫一遍可以根据每个位置留下的信息来确定三元组：

    for (int i = 1; i <= mx; ++i) {
        lst[i] = 0;
    }
    for (int i = n; i >= 1; --i) {
        for (auto &f : fac[a[i]]) {
            lst[f] = i;
        }

        for (auto &[l, g] : info[i]) {
            if (lst[g] != 0) {
                // 确定三元组
                // lst[g] 是第三个数的下标
                // 记录了第一个数的下标和答案
                upd[lst[g]].push_back({ l, g });
            }
        }
    }

有了所有的三元组之后，离线处理询问，将询问按右端点排序。遍历到一个右端点时，通过 upd 中的信息更新，然后进行区间查询最大值。此处用的分块来实现：

// 分块
int sz, block[N + 5], val[N + 5], tag[N + 5];
void set(int pos, int v) {
    if (val[pos] < v) {
        val[pos] = v;
        tag[block[pos]] = std::max(tag[block[pos]], v);
    }
}
int ask(int l, int r) {
    int bl = block[l];
    int br = block[r];

    int ret = 0;
    if (bl == br) {
        for (int i = l; i <= r; ++i) {
            ret = std::max(ret, val[i]);
        }
    }
    else {
        for (int i = l; i <= sz * bl; ++i) {
            ret = std::max(ret, val[i]);
        }
        for (int i = bl + 1; i < br; ++i) {
            ret = std::max(ret, tag[i]);
        }
        for (int i = sz * (br - 1) + 1; i <= r; ++i) {
            ret = std::max(ret, val[i]);
        }
    }
    return ret;
}

void solve() {
    // .......
    for (int i = 1; i <= q; ++i) {
        int l = 0, r = 0;
        std::cin >> l >> r;
        qr[r].push_back({ l, i });
    }

    sz = std::sqrt(n);
    for (int i = 1; i <= n; ++i) {
        block[i] = (i - 1) / sz + 1;
    }
    for (int r = 1; r <= n; ++r) {
        for (auto &[l, g] : upd[r]) {
            set(l, g);
        }

        for (auto &[l, idx] : qr[r]) {
            ans[idx] = ask(l, r);
        }
    }

    // ...... 
}

L

传说中的凹包吗，有意思。

就是问在那些角度里，存在一个侧面的投影包含所有侧面的投影，画个图手玩一下就好了。