@loj - 2865@ 「IOI2018」狼人

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

在日本的茨城县内共有 N 个城市和 M 条道路。这些城市是根据人口数量的升序排列的，依次编号为 0 到 N-1。每条道路链接两个不一样的城市，而且能够双向通行。由这些道路，你能从任意一个城市到另外任意一个城市。

你计划了 Q 个行程，这些行程分别编号为 0 至 Q-1。第 i（0 <= i <= Q - 1）个行程是从城市 Si 到城市 Ei。

你是一个狼人。你有两种形态：人形和狼形。在每一个行程开始的时候，你是人形。在每一个行程结束的时候，你必须是狼形。在行程中，你必需要变身（从人形变成狼形）刚好一次，并且只能在某个城市内（包括多是在 Si 或 Ei 内）变身。

狼人的生活并不容易。当你是人形时，你必须避开人少的城市，而当你是狼形时，你必须避开人多的城市。对于每一次行程 i（0 <= i <= Q - 1），都有两个阈值 Li 和 Ri（0 <= Li <= Ri <= N - 1），用以表示哪些城市必需要避开。
准确地说，当你是人形时，你必须避开城市 0, 1, ..., Li - 1；而当你是狼形时，则必须避开城市 Ri + 1, Ri + 2, ..., N - 1。
这就是说，在行程 i 中，你必须在城市 Li, Li+1, ..., Ri 中的其中一个城市内变身。

你的任务是，对每一次行程，断定是否有可能在知足上述限制的前提下，由城市 Si 走到城市 Ei。你的路线能够有任意长度。

输入格式
你须要实现下面的函数：

int[] check_validity(int N, int[] X, int[] Y, int[] S, int[] E, int[] L, int[] R)

N：城市的数量
X 和 Y：两个长度为 M 的数组。对于每一个 j（0 <= j <= M - 1），城市 X[j] 都有道路直接连到城市 Y[j]。
S, E, L, 及 R：均为长度为 Q 的数组，以表示行程。

数据范围与提示
2 <= N <= 200000, N - 1 <= M <= 400000, 1 <= Q <= 200000。
0 <= Li <= Si <= N - 1, 0 <= Ei <= Ri <= N - 1, Si ≠ Ei, Li <= Ri。
保证没有重边自环，保证图连通。

@solution@

等价的题意：
从 S 出发只通过 L ~ N-1 的点可以到达的点集，与从 E 出发只通过 0 ~ R 的点可以到达的点集，两个集合是否有交集。

现先考虑从 E 出发只通过 0 ~ R 的点可以到达的点。
若是从点 0 到点 N - 1 依次加入它们向前连的边，并用相似于可持久化并查集的东西维护，只要调用第 R 个版本的并查集就能够获得 E 能到达的点。
可持久化并查集？有没有想起 NOI2018 的 D1T1？是否对于这道题咱们也能够转成 kruskal 重构树来作？

考虑对于全部边，记边权为 min{它链接的两个端点的编号}，则只通过 0 ~ R 的点等价于只通过边权 <= R 的边。
因而一个点可以到达的点集，经过倍增能够找到 kruskal 重构树中对应的子树，子树内的全部点都是可到达的。
从 S 出发只通过 L ~ N-1 的点可以到达的点集能够类比着建另外一棵树。

经过 dfs 序，咱们能够把问题转化为：
是否存在一个 (dfn1[x], dfn2[x])，使得 a <= dfn1[x] <= b, c <= dfn2[x] <= d。
经典的二维偏序问题，至关于统计这个二维区域的点数。

我懒得动脑子为了强化代码能力打了个可持久化线段树。
时间复杂度 O(nlogn)。

@accepted code@

#include "werewolf.h"
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define vi vector<int>
#define pb push_back
const int MAXN = 200000;
const int MAXQ = 200000;
const int MAXM = 400000;
int N, M, Q;
struct Graph{
    bool type;
    struct edge{
        int to; edge *nxt;
    }edges[2*MAXN + 5], *adj[2*MAXN + 5], *ecnt;
    int v[2*MAXN + 5], fa[20][2*MAXN + 5];
    Graph(int p) {ecnt = edges, type = p;}
    void addedge(int u, int v) {
        edge *p = (++ecnt);
        p->to = v, p->nxt = adj[u], adj[u] = p;
//      printf("! %d %d\n", u, v);
    }
    void dfs(int x, int f) {
        fa[0][x] = f;
        for(int i=1;i<20;i++)
            fa[i][x] = fa[i-1][fa[i-1][x]];
        for(edge *p=adj[x];p;p=p->nxt)
            dfs(p->to, x);
    }
    void build(int x) {v[0] = type ? (MAXN + 5) : 0; dfs(x, 0);}
    int query(int x, int k) {
        for(int i=19;i>=0;i--)
            if( type ) {
                if( v[fa[i][x]] <= k )
                    x = fa[i][x];
            }
            else {
                if( v[fa[i][x]] >= k )
                    x = fa[i][x];
            }
        return x;
    }
}G1(0), G2(1);
int fa[2*MAXN + 5];
int find(int x) {
    return fa[x] = (fa[x] == x ? x : find(fa[x]));
}
vi e[MAXN + 5];
void build1() {
    int cnt = N;
    for(int i=1;i<(N<<1);i++) fa[i] = i;
    for(int i=N;i>=1;i--) {
        G1.v[i] = i;
        for(int j=0;j<(int)e[i].size();j++)
            if( e[i][j] > i ) {
                int p = e[i][j], f = find(i), g = find(p);
                if( f != g ) {
                    int x = (++cnt);
                    G1.addedge(x, f), G1.addedge(x, g);
                    fa[f] = fa[g] = x;
                    G1.v[x] = i;
                }
            }
    }
    G1.build((N<<1)-1);
}
void build2() {
    int cnt = N;
    for(int i=1;i<(N<<1);i++) fa[i] = i;
    for(int i=1;i<=N;i++) {
        G2.v[i] = i;
        for(int j=0;j<(int)e[i].size();j++)
            if( e[i][j] < i ) {
                int p = e[i][j], f = find(i), g = find(p);
                if( f != g ) {
                    int x = (++cnt);
                    G2.addedge(x, f), G2.addedge(x, g);
                    fa[f] = fa[g] = x;
                    G2.v[x] = i;
                }
            }
    }
    G2.build((N<<1)-1);
}
struct segtree{
    struct node{
        int cnt; node *ch[2];
    }pl[20*MAXN + 5], *NIL, *ncnt;
    segtree() {
        NIL = ncnt = pl;
        NIL->ch[0] = NIL->ch[1] = NIL;
        NIL->cnt = 0;
    }
    node *insert(node *pre, int l, int r, int ps) {
        node *p = (++ncnt); (*p) = (*pre); p->cnt++;
        if( l == r ) return p;
        int mid = (l + r) >> 1;
        if( ps <= mid )
            p->ch[0] = insert(pre->ch[0], l, mid, ps);
        else p->ch[1] = insert(pre->ch[1], mid + 1, r, ps);
        return p;
    }
    int query(node *L, node *R, int l, int r, int ql, int qr) {
        if( ql > r || qr < l ) return 0;
        if( ql <= l && r <= qr ) return R->cnt - L->cnt;
        int mid = (l + r) >> 1;
        return query(L->ch[0], R->ch[0], l, mid, ql, qr) + query(L->ch[1], R->ch[1], mid + 1, r, ql, qr);
    }
}T;
segtree::node *rt[MAXN + 5];
int tid[2][MAXN + 5], dfn[2][MAXN + 5], dcnt[2];
int le[2][2*MAXN + 5], ri[2][2*MAXN + 5];
void dfs(const Graph &G, int x, int t) {
    if( x <= N ) {
        dfn[t][le[t][x] = ri[t][x] = tid[t][x] = (++dcnt[t])] = x;
    }
    else {
        le[t][x] = dcnt[t] + 1;
        for(Graph::edge *p=G.adj[x];p;p=p->nxt)
            dfs(G, p->to, t);
        ri[t][x] = dcnt[t];
    }
}
void get() {
    build1();
    build2();
    dfs(G1, (N<<1)-1, 0), dfs(G2, (N<<1)-1, 1);
    rt[0] = T.NIL;
    for(int i=1;i<=N;i++)
        rt[i] = T.insert(rt[i-1], 1, N, tid[1][dfn[0][i]]);
}
bool query(int s, int e, int l, int r) {
    int x = G1.query(s, l), y = G2.query(e, r);
    return T.query(rt[le[0][x]-1], rt[ri[0][x]], 1, N, le[1][y], ri[1][y]);
}
vi check_validity(int _N, vi X, vi Y, vi S, vi E, vi L, vi R) {
    N = _N, Q = S.size(), M = X.size();
    for(int i=0;i<M;i++)
        e[X[i]+1].pb(Y[i]+1), e[Y[i]+1].pb(X[i]+1);
    get(); vi A(Q);
    for(int i=0;i<Q;i++)
        A[i] = query(S[i]+1, E[i]+1, L[i]+1, R[i]+1);
    return A;
}
/*
S -> L ~ N (L <= S)
E -> 1 ~ R (E <= R)
*/

@details@

对于 kruskal 重构树，其实我更愿意将其看做 “可持久化并查集”。
由于它的做用就是将某时刻 t 以前的加边操做执行后，图连通的状况。

可是某种意义上来讲，kruskal 重构树的思想更相似于点分树之类的东西。即用数据结构再现某一算法的过程。

无论怎么说，会用就行。
另外，比狠人还多一点——是个狼人。