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

最新推荐文章于 2024-07-17 00:28:28 发布

原创最新推荐文章于 2024-07-17 00:28:28 发布 · 242 阅读

0 ·

CC 4.0 BY-SA版权

线段树专栏收录该内容

68 篇文章

订阅专栏

本文详细解析了一道算法题，通过离散化和线段树优化并查集的方法解决从1到n的连通性问题。介绍了如何使用线段树维护区间，实现按秩合并优化并查集，避免路径压缩，确保回溯正确性，最终统计满足条件的区间数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

题意：n个点，m条边，每条边有一个通行范围：[l , r]，问有多少数可以从1到n

题解：先把可行的区间离散化，然后线段树维护下区间，老样子右区间+1进行维护，把所有边可行的区间加入到线段树中，然后线段树从根节点不断向下进行操作，每次按秩合并优化并查集，记住不能路径压缩，因为还得回溯，每操作一个区间，就查询下1和n是否在一个整体，在的话就加上这个区间的贡献，接着返回，没有的话就继续向下dfs

#include <bits/stdc++.h>
using namespace std;
  
typedef long long ll;
const int N = 1e5 + 10;
  
struct node {
    int l, r;
    vector<int> v;
}tree[N * 2 * 4];
int n, m;
int f[N], son[N];
int X[N], Y[N], L[N], R[N];
int b[N << 1], len;
  
void init() {
    for(int i = 0; i <= n; i++) {
        f[i] = i;
        son[i] = 1;
    }
}
void build(int l, int r, int cur) {
    tree[cur].l = l;
    tree[cur].r = r;
    if(l == r) return;
    int mid = (r + l) >> 1;
    build(l, mid, cur << 1);
    build(mid + 1, r, cur << 1 | 1);
}
  
void update(int pl, int pr, int cur, int x) {
    if(pl <= tree[cur].l && tree[cur].r <= pr) {
        tree[cur].v.push_back(x);
        return;
    }
    if(pl <= tree[cur << 1].r) update(pl, pr, cur << 1 , x);
    if(pr >= tree[cur << 1 | 1].l) update(pl, pr, cur << 1 | 1, x);
}
  
int fath(int x) {
    return x == f[x] ? x : fath(f[x]);
}
  
int ans;
  
void dfs(int l, int r, int cur) {
    vector<int> tmp;
    int x, y, pos;
    for(int i = 0; i < tree[cur].v.size(); i++) {
        pos = tree[cur].v[i];
        x = fath(X[pos]);
        y = fath(Y[pos]);
        if(x == y) continue;
        if(son[x] < son[y]) swap(x, y);
        f[y] = x;
        son[x] += son[y];
        tmp.push_back(y);
    }
      
    x = fath(1);
    y = fath(n);
    if(x == y) {
        ans += b[r + 1] - b[l];   
    } else if(l < r) {
        int mid = (r + l ) >> 1;
        dfs(l, mid, cur << 1);
        dfs(mid + 1, r, cur << 1 | 1);
    }
    for(int i = tmp.size() - 1; i >= 0; i--) {
        x = tmp[i], y = f[x];
        f[x] = x;
        son[y] -= son[x];
    }
}
  
int main() {
    int posl, posr;
    scanf("%d %d", &n, &m);
    init();
    for(int i = 1; i <= m; i++) scanf("%d %d %d %d", &X[i], &Y[i], &L[i], &R[i]), b[++len] = L[i], b[++len] = R[i] + 1;
    sort(b + 1, b + 1 + len);
    len = unique(b + 1, b + 1 + len) - (b + 1);
    build(1, len - 1, 1);
    for(int i = 1; i <= m; i++) {
        posl = lower_bound(b + 1, b + 1 + len, L[i]) - b;
        posr = lower_bound(b + 1, b + 1 + len, R[i] + 1) - b;
        update(posl, posr - 1, 1, i);
    }
    dfs(1, len - 1, 1);
    printf("%d\n", ans);
    return 0;
}