Wc2014 紫荆花之恋

哈哈哈哈哈哈哈哈哈哈哈哈我终于过了！！！！！！！！！！！！！！！

从昨天上午就开始写了，下午回家之后调了一会儿没什么感觉，就删了重打了一遍，然后调了一晚上+今天半个上午......我*******终于过了......

我是萌萌的传送门

我是另一个萌萌的传送门

一道极其恶心的动态树分治......

首先点分治，限制条件就变成了di+dj<=ri+rj，移项得rj-dj>=di-ri，对重心和子树开平衡树维护di-ri即可。

查询的时候先跳点分治树更新答案，然后逐层把di-ri插入平衡树，上跳的过程中判断是否有子树失衡(某个子树大于子树总大小的alpha倍)，有则提出来暴力重构成完全平衡的点分治树。

各种坑爹细节和脑残错误调了一天，不过还是过了，激动......

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=100010;
const double alpha=0.7;
struct node{
static int randint(){
static int a=1213,b=97818217,p=998244353,x=751815431;
x=a*x+b;x%=p;
return x<0?(x+=p):x;
}
int data,size,p;
node *ch[2];
node(int d):data(d),size(1),p(randint()){}
inline void refresh(){size=ch[0]->size+ch[1]->size+1;}
}*null=new node(0),*root[maxn],*root1[maxn][50];
void addnode(int,int);
void rebuild(int,int,int,int);
void dfs_getcenter(int,int,int&);
void dfs_getdis(int,int,int,int);
void dfs_destroy(int,int);
void insert(int,node*&);
int order(int,node*);
void destroy(node*&);
void rot(node*&,int);
vector<int>G[maxn],W[maxn];
int size[maxn]={0},siz[maxn][50]={0},son[maxn];
bool vis[maxn];
int depth[maxn],p[maxn],d[maxn][50],id[maxn][50];
int n,m,w[maxn],tmp;
long long ans=0;
int main(){
null->size=0;
null->ch[0]=null->ch[1]=null;
scanf("%*d%d",&n);
fill(vis,vis+n+1,true);
fill(root,root+n+1,null);
for(int i=0;i<=n;i++)fill(root1[i],root1[i]+50,null);
scanf("%*d%*d%d",&w[1]);
insert(-w[1],root[1]);
size[1]=1;
printf("0\n");
for(int i=2;i<=n;i++){
scanf("%d%d%d",&p[i],&tmp,&w[i]);
p[i]^=(ans%(int)1e9);
G[i].push_back(p[i]);
W[i].push_back(tmp);
G[p[i]].push_back(i);
W[p[i]].push_back(tmp);
addnode(i,tmp);
printf("%lld\n",ans);
}
return 0;
}
void addnode(int x,int z){//wj-dj>=di-wi
depth[x]=depth[p[x]]+1;
size[x]=1;
insert(-w[x],root[x]);
int rt=0;
for(int u=p[x],k=depth[p[x]];u;u=p[u],k--){
if(u==p[x]){
id[x][k]=x;
d[x][k]=z;
}
else{
id[x][k]=id[p[x]][k];
d[x][k]=d[p[x]][k]+z;
}
ans+=order(w[x]-d[x][k],root[u])-order(w[x]-d[x][k],root1[id[x][k]][k]);
insert(d[x][k]-w[x],root[u]);
insert(d[x][k]-w[x],root1[id[x][k]][k]);
size[u]++;
siz[id[x][k]][k]++;
if(siz[id[x][k]][k]>size[u]*alpha+5)rt=u;
}
id[x][depth[x]]=0;
d[x][depth[x]]=0;
if(rt){
dfs_destroy(rt,depth[rt]);
rebuild(rt,depth[rt],size[rt],p[rt]);
}
}
void rebuild(int x,int k,int s,int pr){
int u=0;
dfs_getcenter(x,s,u);
vis[x=u]=true;
p[x]=pr;
depth[x]=k;
size[x]=s;
d[x][k]=id[x][k]=0;
destroy(root[x]);
insert(-w[x],root[x]);
if(s<=1)return;
for(int i=0;i<(int)G[x].size();i++)if(!vis[G[x][i]]){
p[G[x][i]]=0;
d[G[x][i]][k]=W[x][i];
siz[G[x][i]][k]=p[G[x][i]]=0;
destroy(root1[G[x][i]][k]);
dfs_getdis(G[x][i],x,G[x][i],k);
}
for(int i=0;i<(int)G[x].size();i++)if(!vis[G[x][i]])rebuild(G[x][i],k+1,size[G[x][i]],x);
}
void dfs_getcenter(int x,int s,int &u){
size[x]=1;
son[x]=0;
for(int i=0;i<(int)G[x].size();i++)if(!vis[G[x][i]]&&G[x][i]!=p[x]){
p[G[x][i]]=x;
dfs_getcenter(G[x][i],s,u);
size[x]+=size[G[x][i]];
if(size[G[x][i]]>size[son[x]])son[x]=G[x][i];
}
if(!u||max(s-size[x],size[son[x]])<max(s-size[u],size[son[u]]))u=x;
}
void dfs_getdis(int x,int u,int rt,int k){
insert(d[x][k]-w[x],root[u]);
insert(d[x][k]-w[x],root1[rt][k]);
id[x][k]=rt;
siz[rt][k]++;
size[x]=1;
for(int i=0;i<(int)G[x].size();i++)if(!vis[G[x][i]]&&G[x][i]!=p[x]){
p[G[x][i]]=x;
d[G[x][i]][k]=d[x][k]+W[x][i];
dfs_getdis(G[x][i],u,rt,k);
size[x]+=size[G[x][i]];
}
}
void dfs_destroy(int x,int k){
vis[x]=false;
for(int i=0;i<(int)G[x].size();i++)if(depth[G[x][i]]>=k&&G[x][i]!=p[x]){
p[G[x][i]]=x;
dfs_destroy(G[x][i],k);
}
}
void insert(int x,node *&rt){
if(rt==null){
rt=new node(x);
rt->ch[0]=rt->ch[1]=null;
return;
}
int d=x>=rt->data;
insert(x,rt->ch[d]);
rt->refresh();
if(rt->ch[d]->p<rt->p)rot(rt,d^1);
}
int order(int x,node *rt){
int ans=0,d;
x++;
while(rt!=null){
if((d=x>rt->data))ans+=rt->ch[0]->size+1;
rt=rt->ch[d];
}
return ans;
}
void destroy(node *&x){
if(x==null)return;
destroy(x->ch[0]);
destroy(x->ch[1]);
delete x;
x=null;
}
void rot(node *&x,int d){
node *y=x->ch[d^1];
x->ch[d^1]=y->ch[d];
y->ch[d]=x;
x->refresh();
(x=y)->refresh();
}
/*
Wc2014 紫荆花之恋
di+dj<=wi+wj，移项得wj-dj>=di-wi，动态点分治维护即可。
每个重心和子树存一棵平衡树维护di-wi，加点的时候跳点分治树更新答案后加入新点，
加入之后判断子树是否失衡，找出最高的失衡节点，把整个子树暴力重构成完全平衡的点分治树。
*/