【BZOJ2049】【LCT】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操作以免超时

【分析】

傻叉了，这种题目写了半个小时。

感觉还是对LCT理解不够。。

  1 /*

  2 唐代白居易

  3 《白云泉》

  4 天平山上白云泉，云自无心水自闲。

  5 何必奔冲山下去，更添波浪向人间。 

  6 */

  7 #include <iostream>

  8 #include <cstdio>

  9 #include <algorithm>

 10 #include <cstring>

 11 #include <vector>

 12 #include <utility>

 13 #include <iomanip>

 14 #include <string>

 15 #include <cmath>

 16 #include <queue>

 17 #include <assert.h>

 18 #include <map>

 19 #include <ctime>

 20 #include <cstdlib>

 21 #include <stack>

 22 #define LOCAL

 23 const int INF = 0x7fffffff;

 24 const int MAXN = 10000  + 10;

 25 const int maxnode = 1000000;

 26 const int maxm= 30000 * 2 + 10;

 27 using namespace std;

 28 

 29 struct Link_Cut_Tree{

 30        struct Node{

 31               int delta;//翻转标记 

 32               int val;//用来debug 

 33               Node *parent;

 34               Node *ch[2];

 35        }node[MAXN], *cur, _nill, *nill;

 36        Node *tmp[MAXN];

 37        

 38        bool is_root(Node* t){//判断是否是splay的根 

 39             if (t == nill || (t->parent->ch[0] != t && t->parent->ch[1] != t)) return 1;

 40             return 0;

 41        }

 42        //这种题还要打标记... 

 43        void pushdown(Node *t){

 44             if (t == nill) return ;

 45             if (t->delta){

 46                t->delta = 0;

 47                if (t->ch[0] != nill) t->ch[0]->delta ^= 1;

 48                if (t->ch[1] != nill) t->ch[1]->delta ^= 1;

 49                swap(t->ch[0], t->ch[1]);

 50             }

 51             return;

 52        } 

 53        void init(){

 54             nill = &_nill;

 55             _nill.val = 0;

 56             _nill.parent = _nill.ch[0] = _nill.ch[1] = nill;

 57             

 58             cur = node + 1;

 59        }

 60        Node* NEW(int val){

 61             cur->parent = cur->ch[0] = cur->ch[1] = nill;

 62             cur->delta = 0;

 63             cur->val = val;

 64             return cur++;

 65        } 

 66        void rotate(Node *t, int d){

 67             if (is_root(t)) return;

 68             Node *p = t->parent;

 69             p->ch[d ^ 1] = t->ch[d];

 70             if (t->ch[d] != nill) t->ch[d]->parent = p;

 71             t->parent = p->parent;

 72             if (p != nill){

 73                if (p->parent->ch[0] == p) p->parent->ch[0] = t;

 74                else if (p->parent->ch[1] == p) p->parent->ch[1] = t;

 75             }

 76             t->ch[d] = p;

 77             p->parent = t;

 78             //update(p);真逗，什么都不要 

 79        } 

 80        //将t旋转到根 

 81        void splay(Node *t){

 82             //标记下传 

 83             int cnt = 1;

 84             tmp[0] = t;

 85             for (Node *y = t; !is_root(y); y = y->parent) tmp[cnt++] = y->parent;

 86             while (cnt) pushdown(tmp[--cnt]);

 87             

 88             while (!is_root(t)){

 89                   Node *y = t->parent;

 90                   if (is_root(y)) rotate(t, (y->ch[0] == t));

 91                   else {

 92                        int d = (y->parent->ch[0] == y);

 93                        if (y->ch[d] == t) rotate(t, d ^ 1);

 94                        else rotate(y, d);

 95                        rotate(t, d);

 96                   }

 97             }

 98        }

 99        Node* access(Node *t){

100             Node *p = nill;

101             while (t != nill){

102                   splay(t);

103                   if (p != nill) p->parent = t;

104                   t->ch[1] = p;

105                   

106                   p = t;

107                   t = t->parent;

108             }

109             return p;

110        }

111        //合并u,v所在的树 

112        void merge(Node *u, Node *v){

113             access(u);

114             splay(u);

115             u->delta = 1;

116             u->parent = v;

117             return; 

118        }

119        void cut(Node *u, Node *v){

120             access(u)->delta ^= 1;

121             //splay(u);//转到顶上就切断v就可以了

122             access(v);

123             splay(v);

124             

125             v->ch[0]->parent = nill;

126             v->ch[0] = nill;

127             return;

128        }

129        bool check(Node *u, Node *v){

130             while (u->parent != nill) u = u->parent;

131             while (v->parent != nill) v = v->parent;

132             return (u == v);

133        }

134 }splay;

135 int n, m;

136  

137 void init(){

138      splay.init();

139      scanf("%d%d", &n, &m);

140      for (int i = 1; i <= n; i++){

141          splay.NEW(i); 

142      }

143 }

144 void work(){

145      for (int i = 1; i <= m; i++){

146          char str[10];

147          scanf("%s", str);

148          if (str[0] == 'C'){

149             int u, v;

150             scanf("%d%d", &u, &v);

151             if (u == v || splay.check(splay.node + u, splay.node + v)) continue;//已经在一个集合里面了

152             splay.merge(splay.node + u, splay.node + v); 

153          }else if (str[0] == 'D'){

154              int u, v;

155              scanf("%d%d", &u, &v);

156              if (u == v || !splay.check(splay.node + u, splay.node + v)) continue;

157              splay.cut(splay.node + u, splay.node + v);

158          }else {

159              int u, v;

160              scanf("%d%d", &u, &v);

161              if (u == v || splay.check(splay.node + u, splay.node + v)) printf("Yes\n");

162              else printf("No\n");

163          }

164      } 

165 }

166 

167 int main (){

168     

169     init();

170     work();

171     return 0;

172 }

View Code