JOISC2024 Day1A Fish 另解

$\text{By hhoppitree.}$

$\mathbf{\text{JOISC2024 Day1A. Fish}}$

题目大意

给定一个长度为 $N$ 的序列 $C$，$Q$ 次询问区间 $[L_i,R_i]$，表示若初始有一个长度为 $R_i-L_i+1$ 的全 $0$ 数组 $A$，每次操作可单点加 $D$ 或者将一个后缀加上 $1$，求最少单点加操作次数使得 $A_i=C_{L+i-1}$，或输出无解。
数据范围：$N,Q\le 3\times {10}^5$，$\mathtt{\text{2s/1GB}}$。

思路分析

考虑将操作倒序进行，那么相当于将每次询问的子段进行最少的单点减 $D$ 操作使得其非严格不降，这可以从后到前贪心，得到了一个 $\mathcal{O}(NQ)$ 的算法。

考虑使用线段树维护，那么我们可以先将拆分出的每个段内先进行调整后再合并调整，例如段 $[L,mid),[mid,R)$，可以先将 $[L,mid)$ 和 $[mid,R)$ 分别调整后对 $[L,mid)$ 的后缀进行调整。

调整可以被拆成若干个后缀减 $D$，我们只需对于每一个线段树的区间 $[L,R]$ 快速计算要求 $C_R\le x$ 时最少的操作次数以及此时 $C_L$ 的值即可。

将 $i,i+1$（经过提前调整后必然有 $C_i\le C_{i+1}$） 之间视作有 $\lfloor {\displaystyle \frac{C_{i+1}-C_i}{D}}\rfloor$ 个空隙，$C_L$ 前有 $\mathrm{\infty }$ 个空隙，那么每次就是将 $[L,R]$ 的最靠后的一个空隙对应的后缀进行后缀减 $D$。

而我们要进行 $\lceil {\displaystyle \frac{x-C_R}{D}}\rceil$ 次这样的操作，后缀和后二分计算出对应的值即可。

时间复杂度为 $\mathcal{O}(N{\log }^{2}N)$，将询问离线后归并计算可以做到 $\mathcal{O}(N\log N)$（视 $N,Q$ 同阶）。

代码呈现

实现了 $\mathcal{O}(N{\log }^{2}N)$ 的算法。

#include <bits/stdc++.h>

using namespace std;

const int N = 3e5 + 5;

long long a[N], D;
vector<long long> arr[1 << 20];
long long opt[1 << 20], sc[1 << 20], pos[1 << 20];
vector< tuple<long long, long long, long long> > z[1 << 20];

void upd(int k) {
    for (int i = 0; i + 1 < (int)arr[k].size(); ++i) {
        z[k].push_back({sc[k], i + 1, pos[k]});
        sc[k] += (arr[k][i] - arr[k][i + 1]) / D;
        pos[k] += (arr[k][i] - arr[k][i + 1]) / D * (i + 1);
    }
}

void build(int k, int l, int r) {
    if (l == r) {
        arr[k].push_back(a[l]);
        upd(k);
        return;
    }
    int mid = (l + r) >> 1;
    build(k << 1, l, mid);
    build(k << 1 | 1, mid + 1, r);
    opt[k] = opt[k << 1] + opt[k << 1 | 1];
    arr[k] = arr[k << 1 | 1];
    for (auto x : arr[k << 1]) {
        if (x > arr[k].back()) {
            opt[k] += ((x - arr[k].back() + D - 1) / D);
            x -= D * ((x - arr[k].back() + D - 1) / D);
        }
        arr[k].push_back(x);
    }
    upd(k);
}

pair<long long, long long> query(int k, int l, int r, int x, int y, long long w) {
    if (l >= x && r <= y) {
        if (w >= arr[k][0]) return {arr[k].back(), opt[k]};
        long long o = (arr[k][0] - w + D - 1) / D;
        if (sc[k] <= o) {
            return {arr[k].back() - (o - sc[k]) * D, opt[k] + pos[k] + (o - sc[k]) * (r - l + 1)};
        }
        auto [a, b, c] = *--upper_bound(z[k].begin(), z[k].end(), tuple<long long, long long, long long>{o, 0, 0});
        return {arr[k].back(), opt[k] + c + (o - a) * b};
    }
    int mid = (l + r) >> 1;
    if (y <= mid) return query(k << 1, l, mid, x, y, w);
    if (x > mid) return query(k << 1 | 1, mid + 1, r, x, y, w);
    pair<long long, long long> rs = query(k << 1 | 1, mid + 1, r, x, y, w);
    pair<long long, long long> ls = query(k << 1, l, mid, x, y, rs.first);
    return {ls.first, ls.second + rs.second};
}

signed main() {
    int n; scanf("%d%lld", &n, &D);
    for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
    build(1, 1, n);
    int q; scanf("%d", &q);
    while (q--) {
        int l, r; scanf("%d%d", &l, &r);
        auto [x, y] = query(1, 1, n, l, r, 1e18);
        if (x < 0) puts("-1");
        else printf("%lld\n", y);
    }
    return 0;
}