[SDOI 2008]Cave 洞穴勘测

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操作以免超时

题解

板子题，一个$0$写成$o$调了一下午。

$LCT$中最主要的是$Access$操作，$Access(u)$操作的含义是，从当前的节点$u$向他所在的根节点连一条重路径，这是相当于把沿路的重路径全都断开，重新拉一条从$u$到根的重路径。

$makeroot(u)$操作：

若想让$u$成为当前树的根节点，则可以先$access(u)$，再$splay(u)$，把$u$转为当前$splay$的根节点。因为$splay$维护的是深度，所以$u$没有右儿子（没有比$u$还要深的点，因为重链定义），所以换根就相当于一次区间翻转，交换左右子树即完成区间翻转。此时就可以打标记了。

所以，$makeroot(u)=access(u)+splay(u)+rev(u)$

$link(x,y)$操作：

在$u$和$v$之间连边，可以$makeroot(u)$，再让$u$的父亲为$v$，这就相当于$v$本身是一棵$splay$，而$u$和$v$之间连了条轻边。

$cut(u,v)$操作：

断开$u$和$v$之间的边，可以先$makeroot(u)$，再$access(v)$，再$splay(v)$，此时$v$的左儿子必定为$u$，于是断开$v$和$v$的左儿子即可。

至于翻转标记的传递，就是跟$Splay$一样就行了。

但标记下放有一个问题。因为$splay$是时时刻刻在分裂与合并的，因为要动态维护每条重链，所以在$splay$之前，要先把根节点到当前节点全部下放一遍标记，防止标记下放不完全。

然后还要保存一些轻边（虚边），对于轻边我们需要单独记录处理。在原树上，当前重链的顶端节点与他的父亲的边即为轻边，如果不记录，树将是不完整的。

具体到代码实现，可以是当前$splay$的根节点的父亲即为当前$splay$上面的那个重链所在的$splay$上的点，但上面的$splay$的儿子并不指向当前$splay$的父亲，即为用$splay$的根节点的父亲来存储轻边。

动态树的主要时间消耗在$Access$上，而$Access$的时间复杂度是$O(nlogn)$。

 //It is made by Awson on 2017.12.21
 #include <map>
 #include <set>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <cstdio>
 #include <string>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 using namespace std;
 const int N = ;

 struct Link_Cut_Tree {
     int ch[N+][], pre[N+], isrt[N+], rev[N+];
         Link_Cut_Tree () {
         memset(isrt, , sizeof(isrt));
     }
     void pushdown(int o) {
         if (!o || !rev[o]) return;
         int ls = ch[o][], rs = ch[o][];
         swap(ch[ls][], ch[ls][]), swap(ch[rs][], ch[rs][]);
         rev[ls] ^= , rev[rs] ^= ; rev[o] = ;
     }
     void rotate(int o, int kind) {
         int p = pre[o];
         ch[p][!kind] = ch[o][kind], pre[ch[o][kind]] = p;
         if (isrt[p]) isrt[o] = , isrt[p] = ;
         else ch[pre[p]][ch[pre[p]][] == p] = o;
         pre[o] = pre[p];
         ch[o][kind] = p, pre[p] = o;
     }
     void push(int o) {
         if (!isrt[o]) push(pre[o]);
         pushdown(o);
     }
     void splay(int o) {
         push(o);
         while (!isrt[o]) {
             if (isrt[pre[o]]) rotate(o, ch[pre[o]][] == o);
             else {
                 int p = pre[o], kind = ch[pre[p]][] == p;
                 if (ch[p][kind] == o) rotate(o, !kind), rotate(o, kind);
                 else rotate(p, kind), rotate(o, kind);
             }
         }
     }
     void access(int o) {
         int y = ;
         while (o) {
             splay(o);
             isrt[ch[o][]] = , isrt[ch[o][] = y] = ;
             o = pre[y = o];
         }
     }
     void makeroot(int o) {
         access(o); splay(o);
         rev[o] ^= ; swap(ch[o][], ch[o][]);
     }
     void link(int x, int y) {
         makeroot(x); pre[x] = y;
     }
     void cut(int x, int y) {
         makeroot(x); access(y); splay(y);
         pre[x] = ch[y][] = , isrt[x] = ;
     }
     void query(int x, int y) {
         while (pre[x]) x = pre[x];
         while (pre[y]) y = pre[y];
         if (x == y) printf("Yes\n");
         else printf("No\n");
     }
 }T;

 int n, m, x, y;
 char s[];

 void work() {
     scanf("%d%d", &n, &m);
     while (m--) {
         scanf("%s%d%d", s, &x, &y);
         if (s[] == 'Q') T.query(x, y);
         else if (s[] == 'C') T.link(x, y);
         else T.cut(x, y);
     }
 }
 int main() {
     work();
     return ;
 }