Tsinsen A1219. 采矿(陈许旻) （树链剖分，线段树 + DP）

【题目链接】

http://www.tsinsen.com/A1219

【题意】

给定一棵树，a[u][i]代表u结点分配i人的收益，可以随时改变a[u]，查询(u,v)代表在u子树的所有节点，在u->v(不含u)路径上的节点分配人数的最优收益。

【思路】

树链剖分：构造重链时先访问重儿子，因此一个重链的区间连续，同时一个子树的区间连续。

查询分为两部分：构造在u子树内分配人数i的最大收益ans1[i]，以及构造在u->v路径上一个结点分配人数i的最大收益ans2[i]。则ans=max{ ans1[i]+ans2[m-i] }。

考虑链剖:一棵线段树维护一条重链上的两类信息，c[i]为任意分配的最优，g[i]为在其中一个分配的最优。则ans1可以通过询问u子树的连续区间得，ans2可以询问u->v路径上的重链得。

需要注意的是线段树中c的递推应该逆序枚举，否则覆盖原值。

【代码】

 #include<set>
 #include<cmath>
 #include<queue>
 #include<vector>
 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long ll;
 const int N = 4e4+;
 const int M = ;
 const ll X = <<;
 const ll Y = ; 

 ll read() {
     char c=getchar();
     ll f=,x=;
     while(!isdigit(c)) {
         if(c=='-') f=-; c=getchar();
     }
     while(isdigit(c))
         x=x*+c-'',c=getchar();
     return x*f;
 }

 struct Edge {
     int v,nxt;
 }e[N<<];
 int en=,front[N];
 void adde(int u,int v)
 {
     e[++en]=(Edge){v,front[u]}; front[u]=en;
 }

 int n,m,C,a[N][M],dfs_list[N],SZ,dfn; ll A,B,Q;
 int dep[N],son[N],top[N],siz[N],fa[N],pl[N],L[N],R[N];

 struct Tnode {
     int u,l,r,c[M],g[M];
     void maintain() ;
 } T[N<<];
 void Tnode::maintain() {
     if(T[u].l==T[u].r) return ;
     memset(c,,sizeof(c));
     FOR(i,,m) FOR(j,,m-i)
         c[i+j]=max(c[i+j],T[u<<].c[i]+T[u<<|].c[j]);
     FOR(i,,m)
         g[i]=max(T[u<<].g[i],T[u<<|].g[i]);
 }

 void build(int u,int l,int r)
 {
     T[u].u=u,T[u].l=l,T[u].r=r;
     if(l==r) {
         memcpy(T[u].c,a[dfs_list[l]],sizeof(T[u].c));
         memcpy(T[u].g,a[dfs_list[l]],sizeof(T[u].g));
         return ;
     }
     int mid=l+r>>;
     build(u<<,l,mid);
     build(u<<|,mid+,r);
     T[u].maintain();
 }
 void update(int u,int x,int* A)
 {
     if(T[u].l==T[u].r) {
         memcpy(T[u].c,A,sizeof(T[u].c));
         memcpy(T[u].g,A,sizeof(T[u].g));
     } else {
         int mid=T[u].l+T[u].r>>;
         if(x<=mid) update(u<<,x,A);
         else update(u<<|,x,A);
         T[u].maintain();
     }
 }
 void query1(int u,int L,int R,int* ans)
 {
     if(L<=T[u].l&&T[u].r<=R) {
         for(int i=m;i;i--) for(int j=i;j;j--)        //逆序枚举i 避免覆盖
             ans[i]=max(ans[i],ans[i-j]+T[u].c[j]);
     } else {
         int mid=T[u].l+T[u].r>>;
         if(L<=mid) query1(u<<,L,R,ans);
         if(mid<R) query1(u<<|,L,R,ans);
     }
 }
 void query2(int u,int L,int R,int* ans)
 {
     if(L<=T[u].l&&T[u].r<=R) {
         FOR(i,,m) ans[i]=max(ans[i],T[u].g[i]);
     } else {
         int mid=T[u].l+T[u].r>>;
         if(L<=mid) query2(u<<,L,R,ans);
         if(mid<R) query2(u<<|,L,R,ans);
     }
 }

 void dfs1(int u)
 {
     siz[u]=; son[u]=;
     trav(u,i) if(e[i].v!=fa[u]) {
         int v=e[i].v;
         fa[v]=u;
         dep[v]=dep[u]+;
         dfs1(v);
         siz[u]+=siz[v];
         if(siz[v]>siz[son[u]]) son[u]=v;
     }
 }
 void dfs2(int u,int tp)
 {
     top[u]=tp; pl[u]=L[u]=++SZ; dfs_list[SZ]=u;
     if(son[u]) dfs2(son[u],tp);
     trav(u,i) if(e[i].v!=fa[u]&&e[i].v!=son[u])
         dfs2(e[i].v,e[i].v);
     R[u]=SZ;
 }
 void query2(int u,int v,int*ans)
 {
     while(top[u]!=top[v]) {
         if(dep[top[u]]<dep[top[v]]) swap(u,v);
         query2(,pl[top[u]],pl[u],ans);
         u=fa[top[u]];
     }
     if(dep[u]>dep[v]) swap(u,v);
     query2(,pl[u],pl[v],ans);
 }

 int get_int()
 {
     A=((A^B)+(B/X)+(ll)(B*X))&Y;
     B=((A^B)+(A/X)+(ll)(A*X))&Y;
     return (int)(A^B)%Q;
 }

 int ans1[M],ans2[M];

 int main()
 {
 //    freopen("in.in","r",stdin);
 //    freopen("out.out","w",stdout);
     n=read(),m=read(),A=read(),B=read(),Q=read();
     int op,u,v;
     FOR(i,,n) {
         u=read(); adde(u,i);
     }
     FOR(i,,n) {
         FOR(j,,m) a[i][j]=get_int();
         sort(a[i]+,a[i]+m+);
     }
     dfs1(); dfs2(,);
     build(,,SZ);
     C=read();
     FOR(i,,C) {
         op=read(),u=read();
         if(op==) {
             FOR(j,,m) a[u][j]=get_int();
             sort(a[u]+,a[u]+m+);
             update(,L[u],a[u]);
         } else {
             v=read();
             memset(ans1,,sizeof(ans1));
             memset(ans2,,sizeof(ans2));
             query1(,L[u],R[u],ans1);
             if(u!=v) query2(fa[u],v,ans2);
             int ans=;
             FOR(i,,m)
                 ans=max(ans,ans1[i]+ans2[m-i]);
             printf("%d\n",ans);
         }
     }
     return ;
 }

P.S.拿线段树DP，这道题实在是太太太太太神辣