csp模拟 我的订书机之恋【树形结构】【哈希】

传送门

事实上标题给的是两种做法。

正解：

一个合法答案只能是最小答案或者由两个答案子区间并集构成。（否则肯定会叉出去）

那就有一个天然树形结构，用单调栈维护f_r表示右端点r最近的合法答案位置。令r向f_r连边，l向f_{l-1}连边。

（当然，上述连边是反向的）

倍增lca的深度-2就是答案，记得特判两个点相同的情况。

#include<bits/stdc++.h>
#define R register
#define ll long long
using namespace std;
const int N = 2100000, inf = 0x3f3f3f3f;
int n, m, a[N], hd[N], to[N], nxt[N], E = 1, fa[N], stck[N], tp, disa[N], dep[N], size[N], top[N];
int S[N], Tm[N], Tmi[N];
inline void A(int x, int y) {
    nxt[++E] = hd[x], hd[x] = E, to[E] = y;
    return;
}
struct IO {
    inline void read(int &x) {
        scanf("%d",&x);
    }
    inline void print(int x) {
        cout<<x<<'\n';
    }
}io;
#define read io.read
#define print io.print
inline void Mi(int x, int w) {
    while (x <= (n << 1)) Tmi[x] = min(Tmi[x], w), x+= x & -x; 
    return;
}

inline int queryMin(int x) {
    int ret = inf;
    while (x) ret = min(ret, Tmi[x]), x -= x & -x;
    return ret;
}

inline void Ma(int x, int w) {
    while (x <= (n << 1)) Tm[x] = max(Tm[x], w), x+= x & -x; 
    return;
}

inline int queryMax(int x) {
    int ret = 0;
    while (x) ret = max(ret, Tm[x]), x -= x & -x;
    return ret;
}

void dfs1(int now) {
    size[now] = 1, dep[now] = dep[fa[now]]+ 1;
    for (R int i = hd[now], v; i; i = nxt[i]) {
        dfs1(v = to[i]), size[now]+= size[v];
        S[now] = size[S[now]]>= size[v] ? S[now] : v;
    }
    return;
}

void dfs2(int now) {
    for (R int i = hd[now], v; i; i = nxt[i])
        v = to[i], top[v] = v == S[now] ? top[now] : v, dfs2(v);
    return;
}

inline int getLca(int x, int y) {
    while (top[x] != top[y])
        dep[top[x]]>= dep[top[y]] ? x = fa[top[x]] : y = fa[top[y]];
    return dep[x]>= dep[y] ? y : x;
}

int main() {
    int x, y, lca;
    read(n), read(m);
    for (R int i = 1; i <= (n << 1);++i)
        read(a[i]);
    for (R int i = (n << 1); i; --i) {
        if (a[i] < i) stck[++tp] = i;
        else {
            while (tp && stck[tp] < a[i])
                disa[stck[tp--]] = 1;
            if (tp && stck[tp] == a[i])
                --tp;
        }
    }
    memset(Tmi, 0x3f, sizeof (Tmi));
    for (R int i = 1; i <= (n << 1);++i) {
        if (a[i]>i)
            Ma((n<<1)-i+1,a[i]);
        if (a[i] < i) {
            fa[i] = min(a[i], queryMin((n << 1) - a[i]+ 1));
            Mi((n << 1) - i+ 1, fa[i]);
            disa[i] = (queryMax((n << 1) - fa[i]+ 1)> i);
        }
    }
    for (R int i = 1; i <= (n << 1);++i)
        if (a[i]> i && a[i - 1] < i - 1 && !disa[i - 1])
            fa[i] = fa[i - 1];
    for (R int i = (n << 1); i; --i)
        fa[i+ 1] = disa[i] ? 1 : fa[i]+ 1, A(fa[i+ 1], i+ 1);
    fa[1] = 0, dfs1(1), dfs2(1);
    while (m--) {
        read(x), read(y);
        if (!x|| !y|| a[x]> x|| a[y] > y) {
            print(0);
            continue;
        }
      ++x,++y, lca = getLca(x, y);
        print(dep[lca] - 1 - (x == y));
    }
    return 0;
}

法2：

考场想的是法2。因为太菜想不到离散化开桶而写了40分，因为忘删调试语句而爆零了。

直接差分错误显然。故给每个括号一个不一样的权值。rand出来（要很大，1e18也有相当的错误概率）

当然，如果像我这样直接相加，很大概率会GG。但使用异或的话，撞车几率就小的多。（2的六十多次方呢）

离散化后从头扫一遍开桶判即可。

实在写不动了，咕