CF765F Souvenirs

给出 $n$ 以及一个长为 $n$ 的序列 $a$。

给出 $m$，接下来 $m$ 组询问。

每组询问给出一个 $l,r$，你需要求出，对于 $i,j \in [l,r]$，且满足 $i \neq j$，$|a_i-a_j|$ 的最小值。

$1 \leq n \leq 10^5$，$1 \leq m \leq 3\times 10^5$，$0 \leq a_i \leq 10^9$。

sol

感觉做分块顺手了许多，不到一小时。

首先看到这题类似于第四分块，于是考虑分块。

考虑对序列分块，取块长为 $\sqrt n$，便利计算时间复杂度，后续可手动调整。

按照套路，先想区间在同一个块内的答案，块内排序，然后暴力计算即可，时间复杂度 $\mathcal O(\sqrt n)$。

如果区间不在同一个块，则分为三个部分：左散块，中多整块，右散块（都是套路了吧）。

记 $s[i][j]$ 表示第 $i$ 块到第 $j$ 块的答案，$f[i][j]$ 表示 $i$ 在块内的 $i$ 前缀与第 $j$ 块到 $i$ 的上一块的答案，$g[i][j]$ 表示 $i$ 所在块内的 $i$ 后缀与 $i$ 的下一块到第 $j$ 块的答案。

对于中多整块的答案，直接查询 $s$ 数组，时间复杂度 $\mathcal O(1)$。

对于左散块及右散块对中间块的答案，直接查询 $f,g$ 数组，时间复杂度 $\mathcal O(1)$。

对于左、右散块的内部答案，由于排序后是有序的，归并双指针计算即可，时间复杂度 $\mathcal O(\sqrt n)$。

最后考虑预处理 $f,g,s$ 。

对于 $f,g$，先计算每个数与每个块的答案，然后前、后缀一下即可，时间复杂度为 $\mathcal O(n \sqrt n)$（注意此时有序，使用双指针优化，时间复杂度不会达到 $\mathcal O(n^2)$）。

那么 $s$ 可由 $f$ 递推而来，时间复杂度 $\mathcal O(n)$。

那么总时空复杂度为 $\mathcal O(n\sqrt n)$。

注意，代码中 $f$ 数组是把上面的 $f,g$ 结合成的，优化空间。

$\text{45.72s / 124.22MB / 3.90KB C++20 O2}$，稍逊于线段树，不过优势是可强制在线。

#include <bits/stdc++.h>

using namespace std;

#define re register

inline int read()
{
    re int x = 0, f = 1;
    re char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
        x = x * 10 + c - '0', c = getchar();
    return x * f;
}

inline void write(re int x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}

inline void cmin(int &a, int b)
{
    a = b > a ? a : b;
}

const int _ = 1e5 + 2, BEL = 320;

int n, m, a[_], blo, ans[_];

int f[_][BEL], s[BEL][BEL], L[BEL], R[BEL];

pair<int, int> b[_];

vector<int> vl, vr;

inline int merge()
{
    re int l1 = 0, l2 = 0, ans = 0x3f3f3f3f;
    for (re int i = 0; i < vl.size() - 1; ++i)
        cmin(ans, vl[i + 1] - vl[i]);
    for (re int i = 0; i < vr.size() - 1; ++i)
        cmin(ans, vr[i + 1] - vr[i]);
    while (l1 < vl.size() && l2 < vr.size())
    {
        cmin(ans, abs(vl[l1] - vr[l2]));
        if (vl[l1] < vr[l2])
            ++l1;
        else
            ++l2;
    }
    return ans;
}

signed main()
{
    n = read();
    for (re int i = 1; i <= n; ++i)
        a[i] = read(), b[i] = {a[i], i};
    blo = (n - 1) / BEL + 1;
    for (re int i = 1; i <= blo; ++i)
        L[i] = R[i - 1] + 1, R[i] = i * BEL;
    R[blo] = n;
    for (re int i = 1; i <= blo; ++i)
        sort(b + L[i], b + R[i] + 1);
    for (re int i = 1; i <= blo; ++i)
    {
        for (re int j = 1; j <= blo; ++j)
            if (i != j)
                for (re int k = L[i], l = L[j]; k <= R[i]; ++k)
                {
                    while (l < R[j] && b[l + 1].first < b[k].first)
                        ++l;
                    f[b[k].second][j] = abs(b[k].first - b[l].first);
                    if (l < R[j])
                        cmin(f[b[k].second][j], abs(b[l + 1].first - b[k].first));
                }
        for (re int k = L[i]; k <= R[i]; ++k)
        {
            for (re int j = i - 2; j >= 0; --j)
                cmin(f[k][j], f[k][j + 1]);
            for (re int j = i + 2; j <= blo; ++j)
                cmin(f[k][j], f[k][j - 1]);
        }
        for (re int j = 1; j < i; ++j)
            for (re int k = L[i] + 1; k <= R[i]; ++k)
                cmin(f[k][j], f[k - 1][j]);
        for (re int j = i + 1; j <= blo; ++j)
            for (re int k = R[i] - 1; k >= L[i]; --k)
                cmin(f[k][j], f[k + 1][j]);
        s[i][i] = 0x3f3f3f3f;
        for (re int j = L[i]; j < R[i]; ++j)
            cmin(s[i][i], b[j + 1].first - b[j].first);
    }
    for (re int i = 1; i <= blo; ++i)
        for (re int j = i + 1; j <= blo; ++j)
            s[i][j] = min(min(s[i][j - 1], f[R[j]][i]), s[j][j]);
    m = read();
    re int l, r, bl, br, ans;
    while (m--)
    {
        l = read(), r = read();
        bl = (l - 1) / BEL + 1, br = (r - 1) / BEL + 1;
        ans = 0x3f3f3f3f;
        if (bl < br)
        {
            if (bl + 1 <= br - 1)
            {
                ans = s[bl + 1][br - 1];
                cmin(ans, min(f[r][bl + 1], f[l][br - 1]));
            }
            vl.clear(), vr.clear();
            for (re int i = L[bl]; i <= R[bl]; ++i)
                if (b[i].second >= l)
                    vl.push_back(b[i].first);
            for (re int i = L[br]; i <= R[br]; ++i)
                if (b[i].second <= r)
                    vr.push_back(b[i].first);
            cmin(ans, merge());
        }
        else
        {
            re int lst = -0x3f3f3f3f;
            for (re int i = L[bl]; i <= R[bl]; ++i)
                if (l <= b[i].second && b[i].second <= r)
                {
                    cmin(ans, b[i].first - lst);
                    lst = b[i].first;
                }
        }
        printf("%d\n", ans);
    }
}