bzoj 4860 [BeiJing2017]树的难题

题面

https://www.lydsy.com/JudgeOnline/problem.php?id=4860

题解

点分治

设当前重心为v

假设已经把所有边按照出发点第一关键字, 颜色第二关键字排序

对于当前的v 我们顺次考虑他的出边

设当前出边(v,nw) 颜色 col

我们枚举nw的出边

对于一条nw的出边而言, 分为两种情况

1. 颜色与col相同   用线段树维护深度及对应的最值,查询到最大值即可 (v,nw)没有贡献

2. 颜色与col不同   用另一棵线段树维护深度以及与(当前节点的连向其父节点的边的颜色)不同的(连向子节点的边)所对应的子节点对应的子树之内的最值 加上col的权值

向上的时候 将线段树合并

Code

 #include <cstdio>
 #include <cctype>
 #include <algorithm>
 const int maxn=,inf=;
 int ans,n,x,y,z,i,m,l,r,c[maxn*],cnt;
 inline int max(int a,int b){
     return a>b?a:b;
 }
 inline void up(int&a,const int&b){
     if(a<b)a=b;
 }
 inline int getint(){
     char c=getchar();
     int x=,neg=;
     while(!isdigit(c)){
         if(c=='-')neg=-;
         c=getchar();
     }
     while(isdigit(c)){
         x=x*+c-;
         c=getchar();
     }
     return x*neg;
 }
 struct edge{
     int from,to,color;
 }e[maxn<<];
 struct data{
     int dep,sum;
 };
 struct node{
     int v,lc,rc;
 }a[maxn*];
 int merge(int x,int y){
     if(!x || !y )return x|y;
     a[x].lc=merge(a[x].lc,a[y].lc);
     a[x].rc=merge(a[x].rc,a[y].rc);
     up(a[x].v,a[y].v);
     return x;
 }
 void add(int&i,int rl,int rr,int x,int v){
     if(!i)a[i=++cnt]=(node){v,,};
         else up(a[i].v,v);
     if(rl<rr){
         int m=(rl+rr)>>;
         if(x>m)add(a[i].rc,m+,rr,x,v);
             else add(a[i].lc,rl,m,x,v);
     }
 }
 int query(int i,int rl,int rr,int l,int r){
     if(!i)return -inf;
     if(rl==l && rr==r)return a[i].v;
     int m=(rl+rr)>>;
     if(l>m)return query(a[i].rc,m+,rr,l,r);
         else if(r<=m)return query(a[i].lc,rl,m,l,r);
             else return max(query(a[i].lc,rl,m,l,m),query(a[i].rc,m+,rr,m+,r));
 }
 struct tree{
     int xb,h[maxn],n,size[maxn],f[maxn],rt,sum,dep[maxn],ll,ss[maxn];
     bool b[maxn];
     data w[maxn];
     void addedge(int x,int y,int z){
         e[++xb]=(edge){y,x,z};
         e[++xb]=(edge){x,y,z};
     }
     void dfs(int x,int fa){
         size[x]=f[x]=;
         for(int i=h[x];i<h[x+];++i){
             int y=e[i].to;
             if(y!=fa && !b[y]){
                 dfs(y,x);
                 size[x]+=size[y];
                 up(f[x],size[y]);
             }
         }
         up(f[x],sum-size[x]);
         if(f[rt]>f[x])rt=x;
     }
     void got(int x,int fa,int dep,int color,int sum){
         for(int y,i=h[x];i<h[x+];++i){
             y=e[i].to;
             if(y!=fa && !b[y]){
                 if(e[i].color==color)w[++ll]=(data){dep+,sum};
                     else w[++ll]=(data){dep+,sum+c[e[i].color]};
                 got(e[i].to,x,dep+,e[i].color,w[ll].sum);
             }
         }
     }
     void solve(int x){
         b[x]=;
         int i,rt1=,rt2=cnt=,j;
         for(i=h[x];i<h[x+];++i){
             if(i>h[x] && e[i].color>e[i-].color)rt1=merge(rt1,rt2),rt2=;
             if(!b[e[i].to]){
                 w[ll=]=(data){,c[e[i].color]};
                 got(e[i].to,x,,e[i].color,c[e[i].color]);
                 ss[i]=ll;
                 for(j=;j<=ll;++j)if(w[j].dep<=r){
                     if(w[j].dep>=l)up(ans,w[j].sum);
                     if(w[j].dep<r){
                         up(ans,query(rt1,,n,max(,l-w[j].dep),r-w[j].dep)+w[j].sum);
                         up(ans,query(rt2,,n,max(,l-w[j].dep),r-w[j].dep)-c[e[i].color]+w[j].sum);
                     }
                 }
                 for(j=;j<=ll;++j)if(w[j].dep<=r)add(rt2,,n,w[j].dep,w[j].sum);
             }
         }
         for(i=h[x];i<h[x+];++i)
             if(!b[e[i].to]){
                 sum=ss[i];
                 rt=;
                 dfs(e[i].to,x);
                 solve(rt);
             }
     }
 }t;
 bool cmp(const edge&a,const edge&b){
     return a.from==b.from?a.color<b.color:a.from<b.from;
 }
 int main(){
     //freopen("input","r",stdin);
     a[].v=-inf;
     t.n=n=getint();
     m=getint();
     l=getint();
     r=getint();
     for(i=;i<=m;++i)c[i]=getint();
     for(i=;i<n;++i){
         x=getint();
         y=getint();
         z=getint();
         t.addedge(x,y,z);
     }
     std::sort(e+,e+((n-)*)+,cmp);
     for(i=;i<=((n-)<<);++i)
         if(!t.h[e[i].from])t.h[e[i].from]=i;
     t.h[n+]=(n-)<<|;
     t.f[t.rt=]=inf;
     t.sum=n;
     ans=-inf;
     t.dfs(,);
     t.solve(t.rt);
     printf("%d\n",ans);
 }

Review

一开始以为是树形dp 后来发现那是错的

还可以用单调队列过 好像更简单