P3250 [HNOI2016] 网络 （树剖+堆/整体二分+树上差分+树状数组）

解法1：

本题有插入路径和删除路径，在每个节点维护插入堆和删除堆，查询时两者top一样则一直弹出。如果每个节点维护的是经过他的路径，显然有些不好处理，正难则反，每个点维护不经过他的路径，那么x节点出了故障时，我们就查询x，查询到的就是x出故障后不受影响的路径。

（洛谷上有一个点一直过不了，似乎是之后加强过的数据）。

#include<bits/stdc++.h>
using namespace std;
const int N=200010;
int tot,sum,head[N],nxt[N<<1],to[N<<1],id[N],top[N],sze[N],son[N],dep[N],fa[N];
int n,m;

inline void add(int x,int y){
    nxt[++tot]=head[x];
    head[x]=tot;
    to[tot]=y;
}

inline int read()
{
  int x=0,flag=1;
  char ch=getchar();
  while(ch<'0'||ch>'9'){if(ch=='-') flag=-1;ch=getchar();}
  while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
  return x*flag;
}

struct node{//每个节点存两个堆 
    priority_queue<int>a,d;
    void push(int x){a.push(x);}
    void del(int x){d.push(x);}
    int top(){
        while(!d.empty()&&a.top()==d.top()) a.pop(),d.pop();
        if(a.empty()) return -1;
        return a.top();
    }
}t[N*5];

struct ac{
    int x,y,z;
}q[N];

struct AC{
    int l,r;
}Data[N];

inline void dfs1(int x,int f){
    dep[x]=dep[f]+1,fa[x]=f,sze[x]=1;
    for(register int i=head[x];i;i=nxt[i]){
        int y=to[i];
        if(y==f) continue;
        dfs1(y,x);
        sze[x]+=sze[y];
        if(sze[y]>=sze[son[x]]) son[x]=y;//曾老给的数据要卡这一步 
    }
}

inline void dfs2(int x,int t){
    top[x]=t;
    id[x]=++sum;
    if(!son[x]) return ;
    dfs2(son[x],t);
    for(register int i=head[x];i;i=nxt[i]){
        int y=to[i];
        if(y!=fa[x]&&y!=son[x])
            dfs2(y,y);
    }
}

bool cmp(AC a,AC b){
    return a.l<b.l;
}

inline void modify(int k,int l,int r,int L,int R,int type,int val){
    if(L>R) return ;
    if(L<=l&&R>=r){
        if(!type) t[k].push(val);
        else t[k].del(val);
        return ;
    }
    int mid=(l+r)>>1;
    if(L<=mid) modify(k<<1,l,mid,L,R,type,val);
    if(R>mid) modify(k<<1|1,mid+1,r,L,R,type,val);
}

inline void update(int x,int y,int type,int val){
    int cnt=0;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        Data[++cnt]=(AC){id[top[x]],id[x]};
        x=fa[top[x]];
    }
    if(dep[x]<dep[y]) swap(x,y);
    Data[++cnt]=(AC){id[y],id[x]};
    sort(Data+1,Data+cnt+1,cmp);
    int last=1;
    for(register int i=1;i<=cnt;i++) modify(1,1,n,last,Data[i].l-1,type,val),last=Data[i].r+1;
    modify(1,1,n,last,n,type,val);
}

inline int query(int k,int l,int r,int x){
    if(l==r&&l==x)
        return t[k].top();
    int mid=(l+r)>>1;
    if(x<=mid) return max(t[k].top(),query(k<<1,l,mid,x));
    else return max(t[k].top(),query(k<<1|1,mid+1,r,x));
}

int main(){
    int x,y,z,type;
    n=read(),m=read();
    for(register int i=1;i<n;i++){
        x=read(),y=read();
        add(x,y);add(y,x);
    }
    dfs1(1,0);dfs2(1,1);//树链剖分 
    for(register int i=1;i<=m;i++){
        type=read();
        if(type==0){
            x=read(),y=read(),z=read();
            update(x,y,0,z);
            q[i]=(ac){x,y,z};//存每条交互链 
        }
        if(type==1){
            x=read();
            update(q[x].x,q[x].y,1,q[x].z);
        }
        if(type==2){
            x=read();
            printf("%d\n",query(1,1,n,id[x]));
        }
    }
    return 0;
}

 解法2：

题目可以使用整体二分的前提就是每组询问可以二分解答。

二分答案值mid，对于要查询的节点x，如果>mid的路径都经过x，那么答案一定小等于mid，反之大于mid。

将所有操作放在一起，标上标记以区分操作类型，套用整体二分的模板就可以了。

具体操作：对于针对的值>mid的操作，采用树上差分的思想，用树状数组维护子数和，统计经过x的>mid的路径有多少条。

（树状数组尤其是可以维护经过每个点的路径有多少条的差分）

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10,INF=1e9;
int dep[N],fa[N],sze[N],son[N],top[N],in[N],out[N],total;
int head[N],to[N<<1],nxt[N<<1],tot;
int n,m,c[N],A[N<<1],B[N<<1],C[N<<1];
struct node{
    int op,t,x,res;
    bool operator<(const node &b) const{return t<b.t;}//保证操作按照时间顺序排列 
}q[N*3],ql[N*3],qr[N*3];
void addedge(int u,int v){
    nxt[++tot]=head[u];
    head[u]=tot;
    to[tot]=v;
}

void dfs1(int u,int f){
    dep[u]=dep[f]+1,sze[u]=1,fa[u]=f;
    in[u]=++total;
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(v!=f){
            dfs1(v,u);
            sze[u]+=sze[v];
            if(sze[v]>sze[son[u]]) son[u]=v;
        }
    }
    out[u]=total;
} 

void dfs2(int u,int t){
    top[u]=t;
    if(son[u]) dfs2(son[u],t);
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(v!=fa[u]&&v!=son[u]) dfs2(v,v);
    }
}

int lca(int u,int v){
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        u=fa[top[u]];
    }
    return dep[u]<dep[v]?u:v;
}

void add(int x,int y){
    for(;x<=n;x+=x&(-x)) c[x]+=y;
}

int ask(int x){
    int res=0;
    for(;x;x-=x&(-x)) res+=c[x];
    return res;
}

void modify(int x,int y,int v){//树上差分 
    int z=lca(x,y);
    add(in[x],v),add(in[y],v),add(in[z],-v);
    if(fa[z]) add(in[fa[z]],-v);
}

void solve(int lval,int rval,int st,int ed){
    if(st>ed) return ;
    if(lval==rval){
        for(int i=st;i<=ed;i++)
            if(q[i].op==2) q[i].res=lval;//记录答案 
        return ;
    }
    int mid=(lval+rval)>>1,cnt=0,lt=0,rt=0;
    for(int i=st;i<=ed;i++){
        if(q[i].op==2){
            int k=ask(out[q[i].x])-ask(in[q[i].x]-1);
            if(k==cnt) ql[++lt]=q[i];
            else qr[++rt]=q[i];
        }
        else{
            if(C[q[i].x]<=mid) ql[++lt]=q[i];
            else{
                int v=q[i].op?-1:1;
                cnt+=v;
                modify(A[q[i].x],B[q[i].x],v);
                qr[++rt]=q[i]; 
            }
        }
    }
    for(int i=1;i<=rt;i++){//还原 
        if(qr[i].op!=2){
            int v=qr[i].op?1:-1;
            modify(A[qr[i].x],B[qr[i].x],v);
        }
    }
    for(int i=1;i<=lt;i++) q[st+i-1]=ql[i];
    for(int i=1;i<=rt;i++) q[st+lt+i-1]=qr[i];
    if(lt) solve(lval,mid,st,st+lt-1);
    if(rt) solve(mid+1,rval,st+lt,ed);
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        addedge(u,v);addedge(v,u);
    }
    dfs1(1,0);dfs2(1,1);
    for(int i=1;i<=m;i++){
        scanf("%d",&q[i].op);
        q[i].t=i;//记录操作编号 
        if(!q[i].op){
            scanf("%d%d%d",&A[i],&B[i],&C[i]);
            q[i].x=i;//记录操作1的编号 
        }
        else scanf("%d",&q[i].x);
    }
    solve(-1,INF,1,m);//值域从-1和INF分，那些无解的就是-1 
    sort(q+1,q+m+1);
    for(int i=1;i<=m;i++){
        if(q[i].op==2) printf("%d\n",q[i].res);
    }
    return 0;
}

 

---

如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮，您的“推荐”将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后必须在文章页面明显位置给出作者和原文连接，否则保留追究法律责任的权利。