BZOJ 3514: Codechef MARCH14 GERALD07加强版 [LCT 主席树 kruskal]

3514: Codechef MARCH14 GERALD07加强版

Time Limit: 60 Sec  Memory Limit: 256 MB
Submit: 1312  Solved: 501
[Submit][Status][Discuss]

Description

N个点M条边的无向图，询问保留图中编号在[l,r]的边的时候图中的联通块个数。

Input

第一行四个整数N、M、K、type，代表点数、边数、询问数以及询问是否加密。
接下来M行，代表图中的每条边。
接下来K行，每行两个整数L、R代表一组询问。对于type=0的测试点，读入的L和R即为询问的L、R；对于type=1的测试点，每组询问的L、R应为L xor lastans和R xor lastans。

Output

K行每行一个整数代表该组询问的联通块个数。

Sample Input

3 5 4 0
1 3
1 2
2 1
3 2
2 2
2 3
1 5
5 5
1 2

Sample Output

2
1
3
1

HINT

对于100%的数据，1≤N、M、K≤200,000。

2016.2.26提高时限至60s

Source

By zhonghaoxi

---

刚刚去看了CreationAugust的Blog，感觉好伤感，也许我的未来就是这样吧

这道题好神啊

LCT维护动态最小生成树，先将每条边依次加进去，若形成环弹掉最早加进去的边，然后记录early[]数组，表示第i条边弹掉了哪条边，若没有弹出边，early[i]=0
然后每个询问的答案就是用n减掉[l,r]区间内ntr值小于l的边的数量 可以用主席树来维护
注意有自环

early[i]数组记录的边不算的话i就可以贡献一个连通分量了，所以这样做

又调了好长时间，最后发现主席树挂掉了因为以前写顺手了虽然是mid=(l+r)>>1但还是用了m...............RE一片

最后说一下一道题用了多个大数据结构怎么办：

1.可以用namespace

2.宏定义是可以取消的，#undef 名字

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define pa t[x].fa
#define lc t[x].ch[0]
#define rc t[x].ch[1]
const int N=2e5+;
typedef long long ll;
inline int read(){
    char c=getchar();int x=,f=;
    while(c<''||c>''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    return x*f;
}

int n,m,Q,type;
struct LCTnode{
    int ch[],fa,rev,w,mx,p;
}t[N<<];
inline int wh(int x){return t[pa].ch[]==x;}
inline int isRoot(int x){return t[pa].ch[]!=x&&t[pa].ch[]!=x;}
inline void update(int x){
    t[x].mx=t[x].w;t[x].p=x;
    if(t[lc].mx>t[x].mx) t[x].mx=t[lc].mx,t[x].p=t[lc].p;
    if(t[rc].mx>t[x].mx) t[x].mx=t[rc].mx,t[x].p=t[rc].p;
}
inline void rever(int x){
    t[x].rev^=;
    swap(lc,rc);
}
inline void pushDown(int x){
    if(t[x].rev){
        rever(lc);
        rever(rc);
        t[x].rev=;
    }
}
inline void rotate(int x){
    int f=t[x].fa,g=t[f].fa,c=wh(x);
    if(!isRoot(f)) t[g].ch[wh(f)]=x;t[x].fa=g;
    t[f].ch[c]=t[x].ch[c^];t[t[f].ch[c]].fa=f;
    t[x].ch[c^]=f;t[f].fa=x;
    update(f);update(x);
}
int st[N],top;
inline void splay(int x){
    top=;st[++top]=x;
    for(int i=x;!isRoot(i);i=t[i].fa) st[++top]=t[i].fa;
    for(int i=top;i>=;i--) pushDown(st[i]);

    for(;!isRoot(x);rotate(x))
        if(!isRoot(pa)) rotate(wh(x)==wh(pa)?pa:x);
}
inline void Access(int x){
    for(int y=;x;y=x,x=pa){
        splay(x);
        rc=y;
        update(x);
    }
}
inline void MakeR(int x){
    Access(x);splay(x);
    rever(x);
}
inline int FindR(int x){
    Access(x);splay(x);
    while(lc) x=lc;
    return x;
}
inline void Link(int x,int y){
    MakeR(x);
    t[x].fa=y;
}
inline void Cut(int x,int y){
    MakeR(x);Access(y);splay(y);
    t[y].ch[]=t[x].fa=;
    update(y);//!!!
}
inline void Split(int x,int y){
    MakeR(x);Access(y);splay(y);
}
inline int Que(int x,int y){
    MakeR(x);Access(y);splay(y);
    return t[y].p;
}

struct edge{
    int u,v;
}e[N];
int early[N];
void Kruskal(){
    for(int i=;i<=m;i++){//printf("kru %d\n",i);
        int u=e[i].u,v=e[i].v;
        if(u==v) {early[i]=i;continue;}
        if(FindR(u)==FindR(v)){
            int p=Que(u,v);
            early[i]=p-n;
            Cut(e[p-n].u,p);Cut(e[p-n].v,p);
        }
        Link(u,i+n);Link(v,i+n);
    }
}

#undef lc
#undef rc
#define lc(x) t[x].l
#define rc(x) t[x].r
namespace F{
    struct Fnode{
        int l,r,size;
    }t[N*];
    int sz=,root[N];
    void ins(int &x,int l,int r,int p){
        t[++sz]=t[x]; x=sz;
        t[x].size++;
        if(l==r) return;
        int mid=(l+r)>>;
        if(p<=mid) ins(t[x].l,l,mid,p);
        else ins(t[x].r,mid+,r,p);
    }
    int que(int x,int y,int l,int r,int ql,int qr){//printf("que %d %d %d %d\n",l,r,ql,qr);
        if(ql<=l&&r<=qr) return t[y].size-t[x].size;
        else{
            int m=(l+r)>>,ans=;
            if(ql<=m) ans+=que(lc(x),lc(y),l,m,ql,qr);
            if(m<qr) ans+=que(rc(x),rc(y),m+,r,ql,qr);
            return ans;
        }
    }
    int l,r,lastans=;
    void solve(){
        for(int i=;i<=m;i++) root[i]=root[i-],ins(root[i],,m,early[i]);
        //for(int i=0;i<=m;i++) printf("root %d\n",root[i]);
        while(Q--){
            l=read();r=read();
            if(type) l^=lastans,r^=lastans;
            lastans=n-que(root[l-],root[r],,m,,l-);
            printf("%d\n",lastans);
        }
    }
}
int main(){
    //freopen("in.txt","r",stdin);
    n=read();m=read();Q=read();type=read();
    for(int i=;i<=m;i++){
        e[i].u=read(),e[i].v=read();
        t[i+n].w=t[i+n].mx=m+n-i+;
        t[i+n].p=i+n;
    }
    Kruskal();
    F::solve();
}