【BZOJ4538】[Hnoi2016]网络
Description
一个简单的网络系统可以被描述成一棵无根树。每个节点为一个服务器。连接服务器与服务器的数据线则看做一条树边。两个服务器进行数据的交互时，数据会经过连接这两个服务器的路径上的所有服务器（包括这两个服务器自身）。由于这条路径是唯一的，当路径上的某个服务器出现故障，无法正常运行时，数据便无法交互。此外，每个数据交互请求都有一个重要度，越重要的请求显然需要得到越高的优先处理权。现在，你作为一个网络系统的管理员，要监控整个系统的运行状态。系统的运行也是很简单的，在每一个时刻，只有可能出现下列三种事件中的一种：1. 在某两个服务器之间出现一条新的数据交互请求；2. 某个数据交互结束请求；3. 某个服务器出现故障。系统会在任何故障发生后立即修复。也就是在出现故障的时刻之后，这个服务器依然是正常的。但在服务器产生故障时依然会对需要经过该服务器的数据交互请求造成影响。你的任务是在每次出现故障时，维护未被影响的请求中重要度的最大值。注意，如果一个数据交互请求已经结束，则不将其纳入未被影响的请求范围。
Input
第一行两个正整数n,m，分别描述服务器和事件个数。服务器编号是从1开始的，因此n个服务器的编号依次是1,2,3,…,n。接下来n-1行，每行两个正整数u,v，描述一条树边。u和v是服务器的编号。接下来m行，按发生时刻依次描述每一个事件；即第i行（i=1,2,3,…,m）描述时刻i发生的事件。每行的第一个数type描述事件类型，共3种类型：（1）若type=0，之后有三个正整数a,b,v，表示服务器a,b之间出现一条重要度为v的数据交互请求；（2）若type=1，之后有一个正整数t，表示时刻t（也就是第t个发生的事件）出现的数据交互请求结束；（3）若type=2，之后有一个正整数x，表示服务器x在这一时刻出现了故障。对于每个type为2的事件，就是一次询问，即询问“当服务器x发生故障时，未被影响的请求中重要度的最大值是多少？”注意可能有某个服务器自身与自身进行数据交互的情况。2 ≤ n ≤ 10^5, 1 ≤ m ≤ 2×10^5，其他的所有输入值不超过 10^9
Output
对于每个type=2的事件，即服务器出现故障的事件，输出一行一个整数，描述未被影响的请求中重要度的最大值。如果此时没有任何请求，或者所有请求均被影响，则输出-1。
题解：网上有二分+路径交的做法，我以前做过路径交的题，这里就不练了。还是整体二分比较自然~
将路径按权值排序，然后将[mid+1,r]中的路径以及询问再按时间排序，接着同时处理操作和询问。对于一个询问，如果[mid+1,r]中没有不经过它的路径，则放到[l,mid]中，否则放到[mid+1,r]中。然后递归做下去即可。
如何知道有多少路径都经过它呢？将路径加，点询问变成点加，子树询问，即x,y权值+1，lca,fa[lca]权值-1，然后统计子树权值和即可。用树状数组实现。
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=200010;
int n,m,np,nq,cnt,now,tot;
int to[maxn],next[maxn],head[maxn],son[maxn],siz[maxn],dep[maxn],fa[maxn],top[maxn];
int P[maxn],Q[maxn],q[maxn],qq[maxn],ref[maxn],s[maxn],ans[maxn],sum[maxn],vis[maxn];
struct node
{
int a,b,lca,v,t,k;
}p[maxn];
int qv[maxn],qt[maxn];
bool cmpv(const node &a,const node &b)
{
return a.v>b.v;
}
bool cmpt(const node &a,const node &b)
{
return a.t<b.t;
}
inline int rd()
{
int ret=0,f=1; char gc=getchar();
while(gc<'0'||gc>'9') {if(gc=='-')f=-f; gc=getchar();}
while(gc>='0'&&gc<='9') ret=ret*10+gc-'0',gc=getchar();
return ret*f;
}
void dfs1(int x)
{
siz[x]=1;
for(int i=head[x];i!=-1;i=next[i]) if(to[i]!=fa[x])
{ fa[to[i]]=x,dep[to[i]]=dep[x]+1,dfs1(to[i]),siz[x]+=siz[to[i]];
if(siz[to[i]]>siz[son[x]]) son[x]=to[i];
}
}
void dfs2(int x,int tp)
{
top[x]=tp,P[x]=++Q[0];
if(son[x]) dfs2(son[x],tp);
for(int i=head[x];i!=-1;i=next[i]) if(to[i]!=fa[x]&&to[i]!=son[x]) dfs2(to[i],to[i]);
Q[x]=Q[0];
}
inline void add(int a,int b)
{
to[cnt]=b,next[cnt]=head[a],head[a]=cnt++;
}
inline int getlca(int x,int y)
{
while(top[x]!=top[y])
{
if(dep[top[x]]<dep[top[y]]) swap(x,y);
x=fa[top[x]];
}
if(dep[x]<dep[y]) return x;
return y;
}
inline void updata(int x,int v)
{
if(!x) return ;
for(int i=x;i<=n;i+=i&-i)
{
if(vis[i]!=now) vis[i]=now,s[i]=0;
s[i]+=v;
}
}
inline int query(int x)
{
int i,ret=0;
for(i=x;i;i-=i&-i)
{
if(vis[i]!=now) vis[i]=now,s[i]=0;
ret+=s[i];
}
return ret;
}
inline void change(int x)
{
if(p[x].v==1<<30) return ;
updata(P[p[x].a],p[x].k),updata(P[p[x].b],p[x].k),updata(P[p[x].lca],-p[x].k),updata(P[fa[p[x].lca]],-p[x].k);
tot+=p[x].k;
}
void solve(int l,int r,int L,int R)
{
if(l>r) return ;
if(p[L].v==p[R].v)
{
for(int i=l;i<=r;i++) ans[q[i]]=p[L].v;
return ;
}
int MID=(L+R)>>1,mid=l-1,i,j=L;
while(p[MID].v==p[MID+1].v&&MID>L) MID--;
now++,tot=0;
sort(p+L,p+MID+1,cmpt);
for(i=l;i<=r;i++)
{
for(;j<=MID&&p[j].t<=qt[q[i]];j++) change(j);
if(query(Q[qv[q[i]]])-query(P[qv[q[i]]]-1)!=tot) sum[q[i]]=1,mid++;
else sum[q[i]]=0;
}
int l1=l,l2=mid+1;
for(i=l;i<=r;i++)
{
if(sum[q[i]]) qq[l1++]=q[i];
else qq[l2++]=q[i];
}
for(i=l;i<=r;i++) q[i]=qq[i];
sort(p+L,p+MID+1,cmpv);
solve(l,mid,L,MID),solve(mid+1,r,MID+1,R);
}
int main()
{
n=rd(),m=rd();
int i,a,b;
memset(head,-1,sizeof(head));
for(i=1;i<n;i++) a=rd(),b=rd(),add(a,b),add(b,a);
dep[1]=1,dfs1(1),dfs2(1,1);
for(i=1;i<=m;i++)
{
a=rd();
if(a==0)
p[++np].a=rd(),p[np].b=rd(),p[np].lca=getlca(p[np].a,p[np].b),p[np].v=rd(),p[np].t=np,p[np].k=1,ref[i]=np;
if(a==1) b=rd(),p[++np]=p[ref[b]],p[np].k=-1,p[np].t=np;
if(a==2) qv[++nq]=rd(),q[nq]=nq,qt[nq]=np;
}
p[0].v=0;
sort(p,p+np+1,cmpv);
solve(1,nq,0,np);
for(i=1;i<=nq;i++) printf("%d\n",(ans[i])?ans[i]:-1);
return 0;
}