洛谷P3250 [HNOI2016]网络（整体二分+树状数组+树剖）

传送门

据说正解是树剖套堆？？？然而代码看着稍微有那么一点点长……

考虑一下整体二分，设当前二分到的答案为$mid$，如果所有大于$mid$的边都经过当前点$x$，那么此时$x$的答案必定小于等于$mid$

然后考虑怎么判断是否所有边都经过某一个点。我们可以用树状数组+树上差分来维护，把每一条边的两个端点的值加1，他们LCA的值减1，LCA父亲的值减1，那么如果这条边经过某一个点，那么这个点子树的和必定为1

于是我们可以把所有大于mid的边都处理出来，然后判断子树的和是否等于路径条数就行了。这个可以用dfs序+树状数组维护

然后整体二分的时候，我们还是能保证时间有序的，如果是修改，那么只有边数大于mid的修改要执行，否则直接扔到左边。询问的话，如果子树和等于大于mid的边数，就扔进左边，否则扔进右边

然后代码里是每一次修改的时候都求一遍LCA的，所以时间复杂度是$O(n\ log^2n)$，如果用ST表求LCA的话应该能再减掉一个$log$

 //minamoto
 #include<bits/stdc++.h>
 using namespace std;
 #define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
 char buf[<<],*p1=buf,*p2=buf;
 template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,:;}
 inline int read(){
     #define num ch-'0'
     char ch;bool flag=;int res;
     while(!isdigit(ch=getc()))
     (ch=='-')&&(flag=true);
     for(res=num;isdigit(ch=getc());res=res*+num);
     (flag)&&(res=-res);
     #undef num
     return res;
 }
 char sr[<<],z[];int K=-,Z;
 inline void Ot(){fwrite(sr,,K+,stdout),K=-;}
 inline void print(int x){
     if(K><<)Ot();if(x<)sr[++K]=,x=-x;
     while(z[++Z]=x%+,x/=);
     while(sr[++K]=z[Z],--Z);sr[++K]='\n';
 }
 const int N=2e5+;
 int head[N],Next[N],ver[N],tot;
 inline void add_edge(int u,int v){
     ver[++tot]=v,Next[tot]=head[u],head[u]=tot;
 }
 struct node{
     int op,x,t,ans;
     inline bool operator <(const node &b)const
     {return t<b.t;}
 }q[N],ll[N],rr[N];
 int n,m,num,c[N],fa[N],top[N],sz[N],son[N],ls[N],rs[N],dep[N],cnt,mx;
 int A[N],B[N],C[N],ans[N];
 inline void add(int x,int y){for(;x<=n;x+=x&-x)c[x]+=y;}
 inline int query(int x){
     int res=;
     for(;x;x-=x&-x) res+=c[x];
     return res;
 }
 inline int query(int l,int r){return query(r)-query(l-);}
 void dfs1(int u){
     sz[u]=,dep[u]=dep[fa[u]]+,ls[u]=++cnt;
     for(int i=head[u];i;i=Next[i]){
         int v=ver[i];
         if(v!=fa[u]){
             fa[v]=u,dfs1(v),sz[u]+=sz[v];
             if(sz[son[u]]<sz[v]) son[u]=v;
         }
     }
     rs[u]=cnt;
 }
 void dfs2(int u,int t){
     top[u]=t;
     if(son[u]){
         dfs2(son[u],t);
         for(int i=head[u];i;i=Next[i])
         if(ver[i]!=fa[u]&&ver[i]!=son[u])
         dfs2(ver[i],ver[i]);
     }
 }
 inline int LCA(int u,int v){
     while(top[u]!=top[v])
     dep[top[u]]>dep[top[v]]?u=fa[top[u]]:v=fa[top[v]];
     return dep[u]<dep[v]?u:v;
 }
 void update(int u,int v,int x){
     int lca=LCA(u,v);
     add(ls[u],x),add(ls[v],x),add(ls[lca],-x);
     if(fa[lca]) add(ls[fa[lca]],-x);
 }
 void solve(int l,int r,int ql,int qr){
     if(l==r){for(int i=ql;i<=qr;++i) if(q[i].op==) q[i].ans=l;return;}
     int mid=(l+r)>>,path=,cl=,cr=;
     for(int i=ql;i<=qr;++i){
         if(q[i].op==){
             if(query(ls[q[i].x],rs[q[i].x])==path) ll[++cl]=q[i];
             else rr[++cr]=q[i];
         }else{
             if(C[q[i].x]<=mid) ll[++cl]=q[i];
             else{
                 int x=q[i].op?-:;path+=x;
                 update(A[q[i].x],B[q[i].x],x);
                 rr[++cr]=q[i];
             }
         }
     }
     for(int i=;i<=cr;++i) if(rr[i].op!=){
         int x=rr[i].op?:-;
         update(A[rr[i].x],B[rr[i].x],x);
     }
     for(int i=;i<=cl;++i) q[ql+i-]=ll[i];
     for(int i=;i<=cr;++i) q[ql+cl+i-]=rr[i];
     if(cl) solve(l,mid,ql,ql+cl-);
     if(cr) solve(mid+,r,ql+cl,qr);
 }
 int main(){
 //    freopen("testdata.in","r",stdin);
     n=read(),m=read();
     for(int i=,u,v;i<n;++i)
     u=read(),v=read(),add_edge(u,v),add_edge(v,u);
     dfs1(),dfs2(,);
     for(int i=;i<=m;++i){
         q[i].op=read(),q[i].t=i;
         if(!q[i].op){
             A[i]=read(),B[i]=read(),C[i]=read();
             q[i].x=i,cmax(mx,C[i]);
         }else q[i].x=read();
     }
     solve(-,mx,,m);
     sort(q+,q++m);
     for(int i=;i<=m;++i)
     if(q[i].op==) print(q[i].ans);
     Ot();
     return ;
 }