Codeforce round 600 div2 D.Harmonious Graph （线段树+并查集）

题目链接：https://codeforces.com/contest/1253/problem/D

题目大意:

给你一个无向图，一个无向图被定义为Harmonious Graph ，必须满足如下条件:

对于两个点l,r(l<r)，如果l到r有路径，那么对于所有l<m<r的点m，点l到点m都必须有路径。

现在你手上有一个无向图，你需要把他变成Harmonious Graph ，问你最少加多少条边。

思路：

对每个连通块用并查集维护一下，合并的时候往编号大的合并，这样，对于每个点u，有一个fa[u]表示这个连通块中最大的点的编号。

对于一个点u，如果他的fa[u]>u，那么对于所有的点u<m<fa[u]，u到这些点的连通块都需要建边，比如说样例1

编号: 1，2，3，4，5，6，7，8，9，10，11，12，13，14

fa[u]:7，7，8，8，7，8，7，8，9，10，12，12，13，14

1节点的fa[1]==7，那么要使1节点满足条件，所有[1,7]区间的节点都应该和1在一个并查集里，不仅如此，如果在[1,7]这个区间内有点v，fa[v]>7的话，所有[1,fa[v]]区间内的节点有应该和1在一个并查集里。

因此，用线段树维护fa[i]这个序列的区间最大值，每次对于一个点u，查询一个[u,fa[u]]的区间最大值maxx，然后不断地查询[u,maxx]区间的区间最大值并更新maxx，直到fa[maxx]==maxx（意味着maxx为一个并查集的顶点），然后再找到区间[u,fa[maxx]]内有多少个不相同的数num，ans+=num-1;

#include <bits/stdc++.h>
using namespace std;

const int maxn=2e5+10;
int fa[maxn];
int find_set(int x){
    return fa[x]==x?fa[x]:fa[x]=find_set(fa[x]);
}
void Union(int x,int y){
    int fx=find_set(x);
    int fy=find_set(y);
    if(fx!=fy){
        if(fx>fy){
            fa[fy]=fx;
        }
        else{
            fa[fx]=fy;
        }
    }
}
struct TreeNode{
    int l,r;
    int maxx;
}Tree[maxn<<2];
void Build(int root,int l,int r){
    Tree[root].l=l,Tree[root].r=r;
    if(l==r){
        Tree[root].maxx=fa[l];
        return ;
    }
    int mid=(l+r)>>1;
    Build(root<<1,l,mid);
    Build(root<<1|1,mid+1,r);
    Tree[root].maxx=max(Tree[root<<1].maxx,Tree[root<<1|1].maxx);
}
int query(int root,int l,int r){
    if(Tree[root].l>=l&&Tree[root].r<=r){
        return Tree[root].maxx;
    }
    int mid=(Tree[root].l+Tree[root].r)>>1;
    if(r<=mid){
        return query(root<<1,l,r);
    }
    else if(l>mid){
        return query(root<<1|1,l,r);
    }
    else return max(query(root<<1,l,mid),query(root<<1|1,mid+1,r));
}
int Q[maxn],cnt;
signed main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)fa[i]=i;
    for(int i=1;i<=m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        Union(u,v);
    }
    for(int i=1;i<=n;i++){
        fa[i]=find_set(fa[i]);
    }
    Build(1,1,n);
    long long ans=0;
    int inx=1;
    while(inx<=n){
        int maxx=query(1,inx,fa[inx]);//区间最大fa的值
        while(query(1,inx,maxx)>maxx){
            maxx=query(1,inx,maxx);
        }
        //printf("debug %d %d\n",inx,maxx);
        if(maxx==inx+1||maxx==inx){
            inx=maxx+1;
            continue;
        }
        //这个区间全要连接
        cnt=0;
        for(int i=inx;i<=maxx;i++){
            Q[++cnt]=fa[i];
        }
        sort(Q+1,Q+cnt+1);
        int num=unique(Q+1,Q+cnt+1)-(Q+1);
        ans+=num-1;
        inx=maxx+1;
    }

    printf("%I64d\n",ans);
    return 0;
}