2019牛客暑期多校训练营（第八场）E - Explorer （线段树+离散化+按秩合并优化的并查集+并查集的拆除）

题意：

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

给你 n 个点，m 条边，每条边给你一组数 (u, v, l, r) 代表如果你想从u点走到v点，你的身高需要满足范围 [ l , r ] ，问你从 1 走到 n 点，你有多少种身高可以选择。

1 ≤ n,m ≤ 10^5,1 ≤ u < v ≤ n,1 ≤ l ≤ r ≤ 10^9

解题思路：

把所有的 l , r 区间离散化之后用线段树来维护每一小段区间的值（之前第七场出过一个这样的题https://blog.csdn.net/ltrbless/article/details/98948649），每个节点维护边的序号（也就是说有哪些路的身高范围是在这段区间内），之后在线段树上进行 dfs 搜索来建立路径，使用并查集判断当前区间的身高是否可以从 1 走到 n 点，并且需要按秩建立并查集，不可以路径压缩，因为递归上去之后之前建立的边需要拆除，一直dfs下去，找到所有满足可以从 1 走到 n 的身高区间。

为了自己以后复习，放一下自己做这个题的笔记：

AC代码：

#include<bits/stdc++.h>
#define up(i, x, y) for(int i = x; i <= y; i++)
#define down(i, x, y) for(int i = x; i >= y; i--)
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
#define IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
typedef long long ll;
typedef unsigned long long ull;
const double eps = 1e-8;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 7;
const double pi = acos(-1);
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
using namespace std;

typedef pair<int, int> P;
int n, m, len, ans;
int dep[maxn], pre[maxn], b[maxn];
vector<int> t[maxn << 2];
struct node
{
    int u, v, l, r;
}a[maxn];

int find_(int x)
{
    while(x != pre[x]) x = pre[x];
    return x;
}

void build(int k, int l, int r, int ql, int qr, int x)
{
    if(ql <= l && r <= qr) //if(l <= ql && qr <= r) 错误！！！ bug  这里的l , r 相当于原来的 t[k].l  t[k].r ，不维护t[k].l  t[k].r，为了节约的空间，因为他们也没用
    {
        t[k].push_back(x); // 保存边，就是说在身高为 [l , r] 的区间内，可以通过边 x 
        return ;
    }
    int mid = (l + r) >> 1;
    if(ql <= mid) build(k << 1, l, mid, ql, qr, x);
    if(mid + 1 <= qr) build(k << 1 | 1, mid + 1, r, ql, qr, x);
}

void dfs(int k, int l, int r)
{
    int siz = t[k].size();
    vector<P> tmp;
    for(int i = 0; i < siz; i++) 
    {
        int o = t[k][i];
        int u = a[o].u, v = a[o].v;
        int fu = find_(u), fv = find_(v);
        if(fu == fv) continue;
        if(dep[fu] < dep[fv]) // 按秩建立并查集
            pre[fu] = fv, tmp.push_back(P{fu, 0}); // 保存，方便拆点
        else if(dep[fu] > dep[fv])
            pre[fv] = fu, tmp.push_back(P{fv, 0});
        else
            pre[fu] = fv, dep[fv]++, tmp.push_back(P{fu, 1});
    }
    if(find_(1) == find_(n))
    {
        ans += b[r + 1] - b[l]; // 该区间的身高可以从1-n，故记录答案
    }
    else if(l < r) // 控制递归深度
    {
        int mid = (l + r) >> 1;
        dfs(k << 1, l, mid);
        dfs(k << 1 | 1, mid + 1, r);
    }
    siz = tmp.size(); 
    for(int i = siz -1 ; i >= 0; i--) // 按反的顺序对并查集进行拆除
    {
        P o = tmp[i];
        dep[ pre[ o.first ] ] -= o.second;
        pre[ o.first ] = o.first;
    }
}

void init()
{
    for(int i = 1; i <= n; i++)
    {
        pre[i] = i;
        dep[i] = 0; // 秩大小,秩在这里就是“并查集”的深度
    }
    len = 0;
    for(int i = 1; i <= m; i++)
    {
        scanf("%d %d %d %d", &a[i].u, &a[i].v, &a[i].l, &a[i].r);
        b[++len] = a[i].l;
        b[++len] = a[i].r + 1; // 为了方便在线段树的根节点表示一个整体，就是任何区间都可以由几个根节点来表示
    }
    sort(b + 1, b + 1 + len);
    len = unique(b + 1, b + 1 + len) - (b + 1); // 离散化
    for(int i = 1; i <= m; i++)
    {
        a[i].l = lower_bound(b + 1, b + 1 + len, a[i].l) - b;
        a[i].r = lower_bound(b + 1, b + 1 + len, a[i].r + 1) - b;
        build(1, 1, len, a[i].l, a[i].r - 1, i); // 更新区间
    }

}

int main()
{
    scanf("%d %d", &n, &m);
    init();
    dfs(1, 1, len);
    printf("%d\n", ans);
}