2049: [Sdoi2008]Cave 洞穴勘测

2049: [Sdoi2008]Cave 洞穴勘测

Time Limit: 10 Sec  Memory Limit: 259 MB

Submit: 7475  Solved: 3499
[Submit][Status][Discuss]

Description

辉辉热衷于洞穴勘测。某天，他按照地图来到了一片被标记为JSZX的洞穴群地区。经过初步勘测，辉辉发现这片区域由n个洞穴（分别编号为1到n）以及若干通道组成，并且每条通道连接了恰好两个洞穴。假如两个洞穴可以通过一条或者多条通道按一定顺序连接起来，那么这两个洞穴就是连通的，按顺序连接在一起的这些通道则被称之为这两个洞穴之间的一条路径。洞穴都十分坚固无法破坏，然而通道不太稳定，时常因为外界影响而发生改变，比如，根据有关仪器的监测结果，123号洞穴和127号洞穴之间有时会出现一条通道，有时这条通道又会因为某种稀奇古怪的原因被毁。辉辉有一台监测仪器可以实时将通道的每一次改变状况在辉辉手边的终端机上显示：如果监测到洞穴u和洞穴v之间出现了一条通道，终端机上会显示一条指令
Connect u v 如果监测到洞穴u和洞穴v之间的通道被毁，终端机上会显示一条指令 Destroy u v
经过长期的艰苦卓绝的手工推算，辉辉发现一个奇怪的现象：无论通道怎么改变，任意时刻任意两个洞穴之间至多只有一条路径。因而，辉辉坚信这是由于某种本质规律的支配导致的。因而，辉辉更加夜以继日地坚守在终端机之前，试图通过通道的改变情况来研究这条本质规律。然而，终于有一天，辉辉在堆积成山的演算纸中崩溃了……他把终端机往地面一砸（终端机也足够坚固无法破坏），转而求助于你，说道：“你老兄把这程序写写吧”。辉辉希望能随时通过终端机发出指令
Query u
v，向监测仪询问此时洞穴u和洞穴v是否连通。现在你要为他编写程序回答每一次询问。已知在第一条指令显示之前，JSZX洞穴群中没有任何通道存在。

Input

第一行为两个正整数n和m，分别表示洞穴的个数和终端机上出现过的指令的个数。以下m行，依次表示终端机上出现的各条指令。每行开头是一个表示指令种类的字符串s（"Connect”、”Destroy”或者”Query”，区分大小写），之后有两个整数u和v
(1≤u, v≤n且u≠v) 分别表示两个洞穴的编号。

Output

对每个Query指令，输出洞穴u和洞穴v是否互相连通：是输出”Yes”，否则输出”No”。（不含双引号）

Sample Input

样例输入1 cave.in
200 5
Query 123 127
Connect 123 127
Query 123 127
Destroy 127 123
Query 123 127
样例输入2 cave.in

3 5
Connect 1 2
Connect 3 1
Query 2 3
Destroy 1 3
Query 2 3

　

Sample Output

样例输出1 cave.out
No
Yes
No

样例输出2 cave.out

Yes
No

　

HINT

　

数据说明
10%的数据满足n≤1000, m≤20000 20%的数据满足n≤2000, m≤40000 30%的数据满足n≤3000, m≤60000
40%的数据满足n≤4000, m≤80000 50%的数据满足n≤5000, m≤100000 60%的数据满足n≤6000, m≤120000
70%的数据满足n≤7000, m≤140000 80%的数据满足n≤8000, m≤160000 90%的数据满足n≤9000, m≤180000
100%的数据满足n≤10000, m≤200000 保证所有Destroy指令将摧毁的是一条存在的通道本题输入、输出规模比较大，建议c\c++选手使用scanf和printf进行I\O操作以免超时

　

Source

【代码】：

#include<cstdio>
#include<iostream>
using namespace std;
int read(){
    int x=,f=;char ch=getchar();
    while(ch<''||ch>'') ch=getchar();
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x;
}
const int N=1e5+;
int n,m,fa[N],st[N],c[N][];
bool rev[N];
bool isroot(int x){//是否是辅助树的链顶,即当前splay 的根
    return c[fa[x]][]!=x&&c[fa[x]][]!=x;
}
void pushdown(int k){//标记下传
    int l=c[k][],r=c[k][];
    if(rev[k]){
        rev[k]^=;rev[l]^=;rev[r]^=;
        swap(c[k][],c[k][]);
    }
}
void rotate(int x){//同splay旋转
    int y=fa[x],z=fa[y],l,r;
    l=(c[y][]==x);r=l^;
    if(!isroot(y)) c[z][c[z][]==y]=x;
    fa[x]=z;fa[y]=x;fa[c[x][r]]=y;
    c[y][l]=c[x][r];c[x][r]=y;
}
void splay(int x){
    int top=;st[++top]=x;
    for(int i=x;!isroot(i);i=fa[i]) st[++top]=fa[i];
    //由于找节点并非自上至下，故操作之前需预先将节点到辅助树根的标记全下传一遍，
    //注意翻转标记只会影响当前这颗树，不会改变整颗树中的顺序。
    for(int i=top;i;i--) pushdown(st[i]);
    while(!isroot(x)){
        int y=fa[x],z=fa[y];
        if(!isroot(y)){//判断y 是否是辅助树中的根节点
            if((c[y][]==x)^(c[z][]==y)) rotate(x);
            else rotate(y);//splay 之字形旋转
        }
        rotate(x);
    }
}
void access(int x){
//将一个点与原先的重儿子切断，并使这个点到根路径上的边全都变为重边，
//执行access(x)函数后这个节点到根的路径上的所有节点形成了一棵Splay，便于操作或查询节点到根路径上的所有节点
    for(int t=;x;x=fa[x]) splay(x),c[x][]=t,t=x;
//将x 转到辅助树的根节点。将x 原来的重儿子斩断 ，但是x的重儿子并未斩断与x的关系，也就是重儿子只是当前存储了当前的路径，
//是不断改变的，下一次询问时还可以重新通过fa记录的关系得到一条新的重链，保证了原树的信息    

}
void rever(int x){//换根，换根换的是原树的根，是把x在原树中正常转动到根结点，在原树转动之后，
//那么原树中对应的深度也相应发生了变化，因为splay维护的是原树的信息，并且是以深度为关键字建树，
//所有树的形态发生翻转，以保证可以通过splay还原原树。
//有一点需要注意就是原树其实不需要维护，他是虚拟的不存在的
    access(x);splay(x);rev[x]^=;
//注意Access(x)之后x不一定是Splay的根节点 所以Access之后通常还要Splay一下
}
void link(int x,int y){//连接，建立新的父子关系
    rever(x);fa[x]=y;splay(x);
}
void cut(int x,int y){//先把x转到他所在链的根
    rever(x);//这里之所以要把x转到他所在子树的根是因为LCT可以维护多棵树，并支持合并，
            //但是如果连接是ｘ不是他所在树的根的话，那么他之前一定有一个父亲节点，连接时就会发生混乱。
    access(y);splay(y);c[y][]=fa[x]=;//因为原树换根后，x,y的位置关系发生了改变，
            //所有y 砍掉的是左儿子，而不是右儿子！！
}
int find(int x){
//判断森林连通性，因为一颗辅助splay的父亲不一定是当前根的父亲，而是重链的的链顶的父亲，
//因为splay是以深度为关键字建树，所有我们要不停的向左子树方向寻找
    access(x);splay(x);
    int y=x;
    while(c[y][]) y=c[y][];
    return y;
}
int main(){
    int x,y;char s[];
    n=read();m=read();
    for(int i=;i<=m;i++){
        scanf("%s",s);x=read();y=read();
        if(s[]=='C') link(x,y);
        else if(s[]=='D') cut(x,y);
        else{
            if(find(x)==find(y)) puts("Yes");
            else puts("No");
        }
    }
    return ;
}

　

附:

Link-Cut-Tree 动态树算法总结

动态树是一类要求维护森林连通性的算法总称，其中最常用的就是lct (Link-Cut-Tree).

lct 支持一下操作

　

链上求和 

链上求最值

链上修改 （前三项均可用树链剖分+线段树实现）

断开树上的一条边

连接两个点，保证连接后仍然是一棵树

判断森林连通性

　

说到lct，自然需要引入一些概念：

Preferred
Child：重儿子(为了便于理解这里沿用树链剖分中的命名)，重儿子与父亲节点同在一棵Splay中，一个节点最多只能有一个重儿子

Preferred Edge：重(zhòng)边，连接父亲节点和重儿子的边

Preferred Path：重链，由重边及重边连接的节点构成的链

由一条重链上的所有节点所构成的Splay称作这条链的辅助树

每个点的关键值为这个点的深度，即这棵Splay的中序遍历是这条链从链顶到链底的所有节点构成的序列

辅助树的根节点的父亲指向链顶的父亲节点，然而链顶的父亲节点的儿子并不指向辅助树的根节点

　

　

原树与辅助树的关系

原树中的重链 -> 辅助树中两个节点位于同一棵Splay中

原树中的轻链 -> 辅助树中子节点所在Splay的根节点的father指向父节点（参见上图）

注意原树与辅助树的结构并不相同

辅助树的根节点≠原树的根节点

辅助树中的father≠原树中的father

由于要维护的信息已经都在辅助树中维护了，所以LCT无需维护原树，只维护辅助树即可，也就是在实际程序中是不存在原树的，即使是原树的换根操作也只是通过辅助树来间接完成。

轻链和重链并不是固定的，随着算法的进行，轻链和重链随算法需要和题目要求而变化，然而无论怎么变化，由这棵辅助树一定能生成原树，并满足辅助树的所有性质

　

这里重点说一下换根操作，也是我刚开始卡住的地方

换根实际上是完成下图的操作：

　

注意这转的是原树！！！！

那么假设1，2，3这三个点在一个splay树中，因为splay是以深度为关键字建树的，所有随着原树中根的改变，本身的深度就发生了变化，原先最深的是3号节点，而换根之后最深的就变成了1号节点，那么我们对splay进行翻转操作，将他的左右子树进行交换，就可以实现深度的更新，很神奇啊！