2019牛客暑期多校训练营（第八场）E Explorer (线段树维护区间 + 并查集 启发式合并优化)

题目链接：https://ac.nowcoder.com/acm/contest/888/E

题意：一些路径上限制通过的人的体型[l， r]  ，问从1到n最多有多少种体型可以通过

这道题的处理方式和牛客第七场的  Find the middle  类似，线段树处理区间  老样子，存左端点，右端点+1，离散化之后，更新线段树，线段树维护每个合法的区间内 边的条数，然后在线段树上  从上到下处理，查看每个区间是否能把1-n连通，判断连通用并查集，由于需要回溯，所以不能压缩路径，为了防止超时用  启发式合并优化，记录每个连通集的size。

 

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 10;
int n, m, ans, cnt, pl, pr;
int f[maxn], son[maxn];
int X[maxn], Y[maxn], L[maxn], R[maxn], b[maxn << 1];

struct node {
    int l, r;
    vector<int> v;
}e[maxn << 3];

inline init() {
    for(int i = 1; i <= n; i++) {
        f[i] = i;
        son[i] = 1;
    }
}

inline void build(int l, int r, int cur){
    e[cur].l = l;
    e[cur].r = r;
    if(l == r) return;
    int mid = l + r >> 1;
    build(l, mid, cur << 1);
    build(mid + 1, r, cur << 1 | 1);
}

inline void update(int l, int r, int cur, int x) {
    if(l <= e[cur].l && e[cur].r <= r){
        e[cur].v.push_back(x);
        return;
    }
    int mid = e[cur].l +e[cur].r >> 1;
    if(l <= mid) update(l, r, cur << 1, x);
    if(r >  mid) update(l, r, cur << 1 | 1, x);
}

int getf(int x) {
    return x == f[x] ? x : getf(f[x]);
}

void dfs(int l, int r,int cur){
    vector<int> v;
    for(int i = 0; i < e[cur].v.size(); i++){
        int pos = e[cur].v[i];
        int x = getf(X[pos]);
        int y = getf(Y[pos]);
        if(x == y) continue;
        if(son[x] < son[y]) swap(x, y);
        f[y] = x;
        son[x] += son[y];
        v.push_back(y);
    }
    int x = getf(1);
    int y = getf(n);
    if(x == y) {
        ans += b[r + 1] - b[l];
    }
    else if(l < r) {
        int mid = l + r >> 1;
        dfs(l, mid, cur << 1);
        dfs(mid + 1, r, cur << 1 | 1);
    }
    for(int i = v.size() - 1; i >= 0; i--){
        y = v[i];
        x = f[y];
        f[y] = y;
        son[x] -= son[y];
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m ; i++){
        scanf("%d%d%d%d", &X[i], &Y[i], &L[i], &R[i]), b[++cnt] = L[i], b[++cnt] = R[i] + 1;
    }
    sort(b + 1, b + cnt + 1);
    cnt = unique(b + 1, b + cnt + 1) -(b + 1);
    build(1, cnt - 1, 1);
    init();
    for(int i = 1; i <= m; i++) {
        pl = lower_bound(b + 1, b + cnt + 1, L[i]) - b;
        pr = lower_bound(b + 1, b + cnt + 1, R[i] + 1) - b;
        update(pl, pr - 1, 1, i);
    }
    dfs(1, cnt - 1, 1);
    printf("%d\n", ans);
    return 0;
}