BZOJ 2049: [Sdoi2008]Cave 洞穴勘测( LCT )

LCT....

---------------------------------------------------------------------------------

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
 
#define rep( i , n ) for( int i = 0 ; i < n ; ++i )
#define clr( x , c ) memset( x , c , sizeof( x ) )
 
using namespace std;
 
const int maxn = 10000 + 5;
 
struct Node *pt , *null;
 
struct Node {
Node *ch[ 2 ] , *p , *fa;
bool isRoot , rev;
Node() {
rev = false;
isRoot = true;
ch[ 0 ] = ch[ 1 ] = fa = p = null;
}
inline void setc( Node* c , int d ) {
ch[ d ] = c;
c -> p = this;
}
inline void relax() {
if( rev ) {
swap( ch[ 0 ] , ch[ 1 ] );
rep( i , 2 ) if( ch[ i ] != null )
   ch[ i ] -> Rev();
rev = false;
}
}
inline void Rev() {
rev ^= 1;
}
inline bool d() {
return this == p -> ch[ 1 ];
}
inline void setRoot( Node* f ) {
fa = f;
isRoot = true;
p = null;
}
void* operator new( size_t ) {
return pt++;
}
};
 
Node NODE[ maxn ];
 
void rot( Node* t ) {
Node* p = t -> p;
p -> relax();
t -> relax();
bool d = t -> d();
p -> p -> setc( t , p -> d() );
p -> setc( t -> ch[ ! d ] , d );
t -> setc( p , ! d );
if( p -> isRoot ) {
p -> isRoot = false;
t -> isRoot = true;
t -> fa = p -> fa;
}
}
 
void splay( Node* t , Node* f = null ) {
static Node* S[ maxn ];
int top = 0;
for( Node* o = t ; o != null ; o = o -> p )
   S[ ++top ] = o;
for( ; top ; top-- )
   S[ top ] -> relax();
for( Node* p = t -> p ; p != f ; p = t -> p ) {
if( p -> p == f ) rot( t );
else if( t -> d() != p -> d()) rot( t ) , rot( t );
else rot( p ) , rot( t );
}
}
 
void access( Node* t ) {
for( Node* o = null ; t != null ; o = t , t = t -> fa ) {
splay( t );
t -> ch[ 1 ] -> setRoot( t );
t -> setc( o , 1 );
}
}
 
Node* findRoot( Node* t ) {
access( t );
splay( t );
while( t -> ch[ 0 ] != null ) {
t -> relax();
t = t -> ch[ 0 ];
}
splay( t );
return t;
}
 
void makeRoot( Node* t ) {
access( t );
splay( t );
t -> Rev();
}
 
void cut( Node* u , Node* v ) {
makeRoot( u );
access( v );
splay( u );
u -> setc( null , 1 );
v -> isRoot = true;
v -> p = v -> fa = null;
}
 
void join( Node* u , Node* v ) {
makeRoot( v );
v -> fa = u;
}
 
void init() {
pt = NODE;
null = new( Node );
}
 
Node* V[ maxn ];
 
int main() {
freopen( "test.in" , "r" , stdin );
init();
int n , m;
cin >> n >> m;
rep( i , n ) V[ i ] = new( Node );
char s[ 10 ];
int u , v;
while( m-- ) {
   scanf( "%s%d%d" , s , &u , &v );
   u-- , v--;
   if( s[ 0 ] == 'Q' ) 
       printf( findRoot( V[ u ] ) != findRoot( V[ v ] ) ? "No\n" : "Yes\n" );
   else if( s [ 0 ] == 'C' )
       join( V[ u ] , V[ v ] );
   else 
       cut( V[ u ] , V[ v ] );
}    
return 0;
}

  

--------------------------------------------------------------------------------- 

2049: [Sdoi2008]Cave 洞穴勘测

Time Limit: 10 Sec  Memory Limit: 259 MB
Submit: 4319  Solved: 1945
[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

 

posted @ 2015-06-17 21:58  JSZX11556  阅读(...)  评论(... 编辑 收藏