UOJ 407(IOI2018 D1T3)

给定一张$n$个点，$m$条边的无向连通图以及$q$次询问，每次询问给出$S,E,L,R$，问你是否能从$S$出发，不经过编号小于$L$的点到达某个编号大于等于$L$且小于等于$R$的点，此时切换状态，不经过编号大于$R$的点到达$E$。

$$nle200000,mle400000,qle200000$$

这种有限制的连通性问题一般考虑Kruskal重构树，对两个限制建出两棵树，倍增找出每个询问能到达的点的区间，然后就是一个经典的二维数点问题了，排序后树状数组解决。

constexpr int MAXN = 200000 + 5, MAXM = 400000 + 5, LOG = 20;

int lg[MAXN * 2];

struct Tree {
  static constexpr int MAX_N = MAXM;

  int hed[MAX_N], nxt[MAX_N * 2], to[MAX_N * 2], val[MAX_N], fa[LOG][MAX_N], dep[MAX_N], L[MAX_N], R[MAX_N], cnt, num;

  void addEdge(int u, int v) {
    ++ cnt;
    to[cnt] = v;
    nxt[cnt] = hed[u];
    hed[u] = cnt;
  }

  void DFS(int u, int total) {
    for (int i = 1; 1 << i <= dep[u]; ++ i) {
      fa[i][u] = fa[i - 1][fa[i - 1][u]];
    }
    if (u <= total) {
      L[u] = R[u] = ++ num;
    } else {
      L[u] = INF, R[u] = 0;
    }
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (v != fa[0][u]) {
        fa[0][v] = u;
        dep[v] = dep[u] + 1;
        DFS(v, total);
        chkmin(L[u], L[v]);
        chkmax(R[u], R[v]);
      }
    }
  }

  int find(int u, int w, const std::function<bool(int, int)> &comp) {
    Rep(i, lg[dep[u]], 0) {
      if (fa[i][u] && comp(val[fa[i][u]], w)) {
        u = fa[i][u];
      }
    }
    return u;
  }
} T1, T2;

struct DSU {
  int fa[MAXN], bel[MAXN];

  void init(int n) {
    For(i, 1, n) {
      fa[i] = bel[i] = i;
    }
  }

  int find(int u) {
    return fa[u] == u ? u : fa[u] = find(fa[u]);
  }

  bool same(int u, int v) {
    return find(u) == find(v);
  }

  void merge(int u, int v, int x) {
    if (!same(u, v)) {
      fa[fa[v]] = fa[u], bel[fa[u]] = x;
    }
  }
} U;

struct BinaryIndexedTree {
  int a[MAXN], length;

#define lowbit(x) ((x) & -(x))
  void init(int n) {
    length = n;
  }

  void modify(int i, int x) {
    for (; i <= length; i += lowbit(i)) {
      a[i] += x;
    }
  }

  int query(int i) {
    int result = 0;
    for (; i; i -= lowbit(i)) {
      result += a[i];
    }
    return result;
  }
#undef lowbit
} BIT;

IL void adjust(std::vector<int> &v) {
  for (auto &x : v) {
    ++ x;
  }
}

std::vector<int> check_validity(int N, std::vector<int> X, std::vector<int> Y,
                                std::vector<int> S, std::vector<int> E,
                                std::vector<int> L, std::vector<int> R) {
  adjust(X), adjust(Y), adjust(S), adjust(E), adjust(L), adjust(R);
  std::vector<std::pair<int, int>> edge(X.size());
  FOR(i, 0, (int)edge.size()) {
    edge[i] = std::make_pair(X[i], Y[i]);
  }
  lg[0] = -1;
  FOR(i, 1, N << 1) {
    lg[i] = lg[i >> 1] + 1;
  }
  int Q = S.size();
  std::vector<int> answer(Q);
  static bool ok[MAXN];
  memset(ok, 1, sizeof ok);
  FOR(i, 0, Q) {
    if (S[i] < L[i] || E[i] > R[i]) {
      ok[i] = 0;
    }
  }
  static std::vector<int> left[MAXN], right[MAXN];
  std::sort(edge.begin(), edge.end(), [](const std::pair<int, int> &a, const std::pair<int, int> &b) -> bool {
    return mymin(a.first, a.second) > mymin(b.first, b.second);
  });
  U.init(N);
  For(i, 1, N) {
    T1.val[i] = i;
  }
  int cnt = 0;
  for (auto &x : edge) {
    if (!U.same(x.first, x.second)) {
      ++ cnt;
      int p = U.fa[x.first], q = U.fa[x.second];
      T1.val[N + cnt] = mymin(T1.val[U.bel[p]], T1.val[U.bel[q]]);
      T1.addEdge(U.bel[p], N + cnt);
      T1.addEdge(N + cnt, U.bel[p]);
      T1.addEdge(U.bel[q], N + cnt);
      T1.addEdge(N + cnt, U.bel[q]);
      U.merge(x.first, x.second, N + cnt);
    }
    if (cnt >= N - 1) {
      break;
    }
  }
  T1.DFS((N << 1) - 1, N);
  FOR(i, 0, Q) {
    if (!ok[i]) {
      continue;
    }
    int u = T1.find(S[i], L[i], [](int a, int b) -> bool {
      return a >= b;
    });
    left[T1.L[u]].push_back(i);
    right[T1.R[u]].push_back(i);
  }
  std::sort(edge.begin(), edge.end(), [](const std::pair<int, int> &a, const std::pair<int, int> &b) -> bool {
    return mymax(a.first, a.second) < mymax(b.first, b.second);
  });
  U.init(N);
  For(i, 1, N) {
    T2.val[i] = i;
  }
  cnt = 0;
  for (auto &x : edge) {
    if (!U.same(x.first, x.second)) {
      ++ cnt;
      int p = U.fa[x.first], q = U.fa[x.second];
      T2.val[N + cnt] = mymax(T2.val[U.bel[p]], T2.val[U.bel[q]]);
      T2.addEdge(U.bel[p], N + cnt);
      T2.addEdge(N + cnt, U.bel[p]);
      T2.addEdge(U.bel[q], N + cnt);
      T2.addEdge(N + cnt, U.bel[q]);
      U.merge(x.first, x.second, N + cnt);
    }
    if (cnt >= N - 1) {
      break;
    }
  }
  T2.DFS((N << 1) - 1, N);
  std::vector<std::pair<int, int>> interval(Q);
  FOR(i, 0, Q) {
    if (!ok[i]) {
      continue;
    }
    int u = T2.find(E[i], R[i], [](int a, int b) -> bool {
      return a <= b;
    });
    interval[i] = std::make_pair(T2.L[u], T2.R[u]);
  }
  static std::vector<int> point[MAXN];
  For(i, 1, N) {
    point[T1.L[i]].push_back(T2.L[i]);
  }
  BIT.init(N);
  For(i, 1, N) {
    for (auto &x : left[i]) {
      answer[x] = BIT.query(interval[x].second) - BIT.query(interval[x].first - 1);
    }
    for (auto &x : point[i]) {
      BIT.modify(x, 1);
    }
    for (auto &x : right[i]) {
      answer[x] = !!(BIT.query(interval[x].second) - BIT.query(interval[x].first - 1) - answer[x]);
    }
  }
  return answer;
}