1095: [ZJOI2007]Hide 捉迷藏
Time Limit: 40 Sec Memory Limit: 256 MB
Description
捉迷藏 Jiajia和Wind是一对恩爱的夫妻，并且他们有很多孩子。某天，Jiajia、Wind和孩子们决定在家里玩
捉迷藏游戏。他们的家很大且构造很奇特，由N个屋子和N-1条双向走廊组成，这N-1条走廊的分布使得任意两个屋
子都互相可达。游戏是这样进行的，孩子们负责躲藏，Jiajia负责找，而Wind负责操纵这N个屋子的灯。在起初的
时候，所有的灯都没有被打开。每一次，孩子们只会躲藏在没有开灯的房间中，但是为了增加刺激性，孩子们会要
求打开某个房间的电灯或者关闭某个房间的电灯。为了评估某一次游戏的复杂性，Jiajia希望知道可能的最远的两
个孩子的距离（即最远的两个关灯房间的距离）。 我们将以如下形式定义每一种操作： C(hange) i 改变第i个房
间的照明状态，若原来打开，则关闭；若原来关闭，则打开。 G(ame) 开始一次游戏，查询最远的两个关灯房间的
距离。
Input
第一行包含一个整数N，表示房间的个数，房间将被编号为1,2,3…N的整数。接下来N-1行每行两个整数a, b，
表示房间a与房间b之间有一条走廊相连。接下来一行包含一个整数Q，表示操作次数。接着Q行，每行一个操作，如
上文所示。
Output
对于每一个操作Game，输出一个非负整数到hide.out，表示最远的两个关灯房间的距离。若只有一个房间是关
着灯的，输出0；若所有房间的灯都开着，输出-1。
Sample Input
8
1 2
2 3
3 4
3 5
3 6
6 7
6 8
7
G
C 1
G
C 2
G
C 1
G
Sample Output
4
3
3
4
HINT
对于100%的数据， N ≤100000, M ≤500000。
题目大意：给定一棵树，一开始每个点都是黑点，多次改变某个点的状态或询问距离最远的两个黑点的距离
思路：
树上的链问题，容易想到点分。
但是跟一般的点分治不同，这里我们要支持修改，也就是动态点分治。
怎么做呢？考虑把分治过程中所有重心都连起来得到一棵新树。
修改就是要从下往上把所有的祖先都修改了。
这棵树的高度不会超过O(logn)，所以修改就是log级别的。
要修改就不得不把dis记录下来，我们要找最长，于是考虑用大根堆维护。
我们每个重心开两个堆，第一个堆记录子树中所有节点到父亲节点的距离（f[]），第二个堆记录所有子节点的堆顶（c[]），详见代码。
那么一个节点的堆c中的最大和次大加起来就是子树中经过这个节点的最长链。
最后开一个堆，维护答案。
怎么删改呢？还是大佬的方法好。
开始时堆c中要插一个0表示单链可以算，而改为白点的时候0就删掉了（不能做端点）。
又去偷了一个封装双堆。（YY了很久都没想到怎么删除）
封装双堆分别为值和删了的值，取的时候两堆顶相同则pop，相当于变种删除标记。
然后。。。膜大佬。。。
#include<queue>
#include<cstdio>
#include<iostream>
using namespace std;
const int N = 100005;
int idc=0, n, m, core=0, size;
int head[N],vis[N],siz[N],deep[N],acc[N][21],mn[N],col[N],prt[N];
struct Priority_Queue{
priority_queue<int>q, del;//储存堆， 删除堆
void push(int x){ q.push(x); }
void erase(int x){ del.push(x); }
int top(){
while(del.size() && del.top()==q.top()){
del.pop(); q.pop();//先删除
}
return q.top();
}
void Pop(){
while(del.size() && del.top()==q.top()){
del.pop(); q.pop();//先删除
}
q.pop();
}
int sec_top(){//第二大元素
int tmp = top(); Pop();
int cc = top(); push(tmp);
return cc;
}
int size(){
return q.size() - del.size();
}
}c[N], f[N], ans;
//c[i]储存从i点出发所有的链长
//f[i]储存i为重心的子树中所有点到i上一级重心的dis
struct Edge{
int to, next;
}ed[N*2];
void adde(int u, int v){
ed[++idc] = (Edge){v, head[u]};
head[u] = idc;
}
void dfs(int u, int fa){//初始化st，deep
acc[u][0] = fa;
for(int i=1; i<=20; i++)
acc[u][i]=acc[acc[u][i-1]][i-1];
for(int k=head[u]; k; k=ed[k].next){
int v = ed[k].to;
if(v == fa)continue;
deep[v] = deep[u] + 1;
dfs(v, u);
}
}
void getcore(int u, int fat){
siz[u] = 1, mn[u] = 0;
for(int k=head[u]; k; k=ed[k].next){
int v = ed[k].to;
if(v == fat || vis[v]) continue;
getcore(v, u);
siz[u] += siz[v];
mn[u] = max(mn[u], siz[v]);//所有子树中最大的
}
mn[u] = max(mn[u], size-siz[u]);//与上边的部分比较（fa所在的数）
if(mn[u] < mn[core])
core = u;//重心
}
int lca(int x, int y){//倍增求lca
if(deep[x] < deep[y]) swap(x, y);
for(int j=20; j>=0; j--)
if(deep[acc[x][j]] >= deep[y]) x = acc[x][j];
if(x == y) return x;
for(int j=20; j>=0; j--)
if(acc[x][j] != acc[y][j]){
x = acc[x][j]; y = acc[y][j];
}
return acc[x][0];
}
int dis(int x, int y){
return deep[x] + deep[y] - 2*deep[lca(x, y)];//两点间距离
}
void work(int u, int fa, int Gra){//当前块中每个点到上一级重心的dis
f[Gra].push( dis(u, prt[Gra]) );
for(int k=head[u]; k; k=ed[k].next){
int v = ed[k].to;
if(v == fa || vis[v]) continue;
work(v, u, Gra);
}
}
void Insert(Priority_Queue &cc){
if(cc.size() > 1)
ans.push(cc.top() + cc.sec_top());//ans由cc出发不在同一子树最长的两条链构成
//在同一子树的情况一定会被下一级的重心统计到
}
void Erase(Priority_Queue &cc){
if(cc.size() > 1)
ans.erase(cc.top() + cc.sec_top());
}
int solve(int x, int fa){
size = siz[x]; core = 0;//还原为0
getcore(x, 0); int G = core;//重心
prt[G] = fa;//上一级中心
work(G, 0, G);
vis[G] = 1;//断开
c[G].push(0);//G可以作为端点
for(int k=head[G]; k; k=ed[k].next){
int v = ed[k].to;
if( !vis[v] ){
int GG = solve(v, G);
c[G].push( f[GG].top() );
}
}
Insert( c[G] );
return G;
}
void turnon(int x){//变白
Erase( c[x] );//变白点之后影响的只可能是以x为端点的链
//而因为我们是点分治，所以这些链一定是是在x的统计中（c[x]中）
c[x].erase( 0 );
//我们去除了0，就是说当c[x].size==2时（包含0），不能再统计了（此时端点为x）
//当c[x].size>2时（包含0），以x为端点的链一定不是最长链，不用考虑
Insert( c[x] );
for(int i=x; prt[i]; i=prt[i]){
Erase( c[prt[i]] );
if( f[i].size() ) c[prt[i]].erase( f[i].top() );
f[i].erase( dis(x, prt[i]) );//x不能成为端点，所以重心到x的dis删除
if( f[i].size() ) c[prt[i]].push( f[i].top() );//更新
Insert( c[prt[i]] );
}
}//Erase -> erase/push -> Insert 就是修改操作
void turnoff(int x){//变黑
Erase( c[x] );//只影响x点做出的最大贡献
c[x].push( 0 );//类比上边，这里可以统计以x为端点的链
Insert( c[x] );
for(int i=x; prt[i]; i=prt[i]){
Erase( c[prt[i]] );//处理上一级的中心
if( f[i].size() ) c[prt[i]].erase( f[i].top() );
//针对上一级重心，影响的只有x所在的子树，为什么只考虑top？
//（因为只影响最优解，不是最优解的话，当它成为最优解时就会被删掉，
//【q中最优那么del中一定也最最优】，它不成为最优就不会删掉，但是也不会对答案产生影响）
f[i].push( dis(x, prt[i]) );//x能成为端点，所以重心到x的dis加入
if( f[i].size() ) c[prt[i]].push( f[i].top() );
Insert( c[prt[i]] );//更新
}
}
int main(){
scanf("%d", &n);
for(int i=1; i<n; i++){
int u, v;
scanf("%d%d", &u, &v);
adde(u, v); adde(v, u);//开始全为黑点
}
deep[1] = 1; dfs(1, 0);//预处理deep
siz[1] = n; mn[core] = n + 1;//***
solve(1, 0);//
int num = n;//黑点数
scanf("%d", &m);
for(int i=1; i<=m; i++){
char ch[5]; scanf("%s", ch);
if(ch[0] == 'G'){
if(num <= 1) printf("%d\n", num-1);//0 | -1
else printf("%d\n", ans.top());
}
else{
int x; scanf("%d", &x);
if( !col[x] ){
num--;
turnon(x);
col[x] = 1;
}
else{
num++;
turnoff(x);
col[x] = 0;
}
}
}
return 0;
} 
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
