题意:一棵树,多次给指定链上的节点加1,问最大节点权值

n个点,n-1条边很容易惯性想成一条链,幸好有样例..

 

简单的树剖即可!(划去)

正常思路是树上差分,毕竟它就询问一次..

#include<iostream>
#include<cstring>
#include<cstdio>

using namespace std;

inline int rd(){
    int ret=0,f=1;char c;
    while(c=getchar(),!isdigit(c))f=c=='-'?-1:1;
    while(isdigit(c))ret=ret*10+c-'0',c=getchar();
    return ret*f;
}

const int MAXN=500005<<2;

struct Edge{
    int next,to;
    Edge(int x=0,int 
    y=0){next=x;to=y;}
}e[MAXN];
int ecnt,head[MAXN];
inline void add(int x,int y){
    e[++ecnt]=Edge(head[x],y);
    head[x]=ecnt;
}

int n,m;

int fa[MAXN],dep[MAXN],siz[MAXN],hs[MAXN];
void dfs1(int x,int pre){
    fa[x]=pre;dep[x]=dep[pre]+1;siz[x]=1;
    int mx=0,tmp=0;
    for(int i=head[x];i;i=e[i].next){
        int v=e[i].to;
        if(v==pre) continue;
        dfs1(v,x);
        siz[x]+=siz[v];
        if(siz[v]>mx){mx=siz[v];tmp=v;}
    }
    hs[x]=tmp;
}

int top[MAXN],id[MAXN],tot;
void dfs2(int x,int tp){
    top[x]=tp;id[x]=++tot;
    if(hs[x]) dfs2(hs[x],tp);
    for(int i=head[x];i;i=e[i].next){
        int v=e[i].to;
        if(v==fa[x]||v==hs[x]) continue;
        dfs2(v,v);
    }
}

int lca(int x,int y){
    int ret;
    while(top[x]!=top[y]){
        dep[top[x]]>dep[top[y]]?x=fa[top[x]]:y=fa[top[y]];
    }
    return dep[x]<dep[y]?x:y;
}
        
int ans,sum[MAXN];
void dfs(int cur){
    for(int i=head[cur];i;i=e[i].next){
        int v=e[i].to;
        if(v==fa[cur]) continue;
        dfs(v);
        sum[cur]+=sum[v];
    }
    ans=max(sum[cur],ans);
}
                

int main(){
    n=rd();m=rd();
    int x,y,t;
    for(int i=1;i<=n-1;i++){
        x=rd();y=rd();
        add(x,y);add(y,x);
    }
    dfs1(1,0);
    dfs2(1,1);
    for(int i=1;i<=m;i++){
        x=rd();y=rd();t=lca(x,y);
        sum[x]+=1;sum[y]+=1;
        sum[t]-=1;sum[fa[t]]-=1;
    }
    dfs(1);
    cout<<ans<<endl;
    return 0;
}
树上差分

相关文章:

  • 2022-01-04
  • 2022-12-23
  • 2021-08-17
  • 2021-07-16
  • 2021-11-10
  • 2022-01-16
  • 2021-04-10
  • 2021-10-21
猜你喜欢
  • 2021-08-31
  • 2021-10-17
  • 2022-01-01
  • 2021-12-26
  • 2021-07-09
  • 2022-12-23
相关资源
相似解决方案