长链剖分优化dp三例题

　　首先，重链剖分我们有所认识，在dsu on tree和数据结构维护链时我们都用过他的性质。

　　在这里，我们要介绍一种新的剖分方式，我们求出这个点到子树中的最长链长，这个链长最终从哪个儿子更新而来，那个儿子就是所谓的“重儿子”，也可以叫长儿子。

　　我们的做法就是，在统计一个点的信息时，对于重儿子，我们直O(1)接继承它的答案（这里有指针技巧，只能看代码，不可言传），对于轻儿子我们暴力统计。

　　复杂度分析：一个点被计算，最多只会在作为重链上的点时被继承一次，在重链顶端时被暴力统计一次。所以最终复杂度是O(N)的。

　　因为我们这里要谈的是dp优化，所以我们还没有必要研究这个结构的性质。

　　它有两个应用，首先就是优化以链长度为下标的树形dp，也就是今天我们要谈的玩法，还有一个是快速求一个点的k级祖先，这个我们先不研究。

　　只凭语言大家很难体会到这个算法的难度，下面我们看一些题目。

首先是CF1009：

　　这道题完全可以用dsu on tree的科技过去，但是为了能入手一道简单的长剖题目，我们还是思考一下。

　　如果设计一个dp：dp[i][j]表示以i为根的子树内离i距离为j的节点个数。转移方程也就很好写了：dp[x][j]+=dp[y][j-1]。(y是x的儿子)，我们观察，在继承一个儿子的答案时，儿子的数组整体左移一个元素的位置可以直接贡献给父亲，于是我们就做到了O(1)继承。

　　于是暴力统计其他儿子的时候我们直接按方程转移即可。

　代码：

 //倔强芬芳了惘然
 #pragma GCC optimize(3)
 #include<bits/stdc++.h>
 using namespace std;
 const int N=;
 struct node{int y,nxt;}e[N*];
 int n,m,a[N],d[N],fa[N],son[N],h[N];
 int ans[N],cnt[N],c,st[N],tt;
 void add(int x,int y){
     e[++c]=(node){y,h[x]};h[x]=c;
     e[++c]=(node){x,h[y]};h[y]=c;
 } void dfs(int x){ d[x]=;
     for(int i=h[x],y;i;i=e[i].nxt)
     if((y=e[i].y)!=fa[x]){
         fa[y]=x;dfs(y);d[x]=max(d[x],d[y]+);
         if(d[y]>d[son[x]]) son[x]=y;
     } return ;
 } void solve(int x){
     int *f=&cnt[st[x]=++tt],*g;
     f[ans[x]=]=;
     if(son[x]) solve(son[x]),
     ans[x]=ans[son[x]]+;else return ;
     if(ans[x]==) ans[x]=;
     for(int i=h[x],y;i;i=e[i].nxt)
     if((y=e[i].y)!=fa[x]&&y!=son[x]){
         solve(y);g=&cnt[st[y]];
         for(int j=;j<=d[y]-;j++)
           if((f[j+]+=g[j])>=f[ans[x]]&&j+<ans[x]||
         f[j+]>f[ans[x]]) ans[x]=j+;
     } return ;
 } void solve(){
     dfs();solve();
     for(int i=;i<=n;i++)
     printf("%d\n",ans[i]);
 } int main(){
     scanf("%d",&n);
     for(int i=,x,y;i<n;i++)
     scanf("%d%d",&x,&y),add(x,y);
     solve();return ;
 }

长链剖分

现在是POI2014Hotels

　　其实大部分人对计数题还是有一定抵触的，因为一些做法的正确性很难把握。dp是很常用的计数手段，但是这个题的dp方程很有意思。向各位推荐一篇题解→luogu题解1

　　我们只借用它的方程考虑这个能不能直接O(1)继承重儿子的答案？（当然可以啦）

　　但是我们注意，f数组和g数组在继承的时候方向是不一样的，因为这一点，我们最好在递归之前就为下面的计算分配好指针，来保证顺利继承，另外，在空间分配上，这个题也很巧妙。因为我们在长链上，f数组不断向后偏移，g数组不断向前偏移，所以我们要为每段数组预留出两个链长的空间，很难描述，还是要去研究代码来理解这种分配规则。可以说这是一道不看题解不好做的题目。

 #include<bits/stdc++.h>
 #define ll long long
 using namespace std;
 const int N=;
 struct node{int y,nxt;}e[N*];
 int h[N],d[N],son[N],c,n,m,k,p;
 ll tmp[N*],*id=tmp,*f[N],*g[N],ans=;
 void add(int x,int y){
     e[++c]=(node){y,h[x]};h[x]=c;
     e[++c]=(node){x,h[y]};h[y]=c;
 } void dfs(int x,int fa){
     d[x]=;for(int i=h[x],y;i;i=e[i].nxt)
     if((y=e[i].y)!=fa){
         dfs(y,x);d[x]=max(d[x],d[y]+);
         if(d[y]>d[son[x]]) son[x]=y;
     } return ;
 } void solve(int x,int fa){
     if(son[x]) f[son[x]]=f[x]+,
     g[son[x]]=g[x]-,solve(son[x],x);
     f[x][]=;
     for(int i=h[x],y;i;i=e[i].nxt)
     if((y=e[i].y)!=fa&&y!=son[x]){
         f[y]=id;id+=d[y]*;g[y]=id;
         id+=d[y]*;solve(y,x);
         for(int j=;j<d[y];j++){
             if(j) ans+=(f[x][j-]*g[y][j]);
             ans+=(f[y][j]*g[x][j+]);
         } for(int j=;j<d[y];j++){
             if(j) g[x][j-]+=g[y][j];
             g[x][j+]+=f[x][j+]*f[y][j];
             f[x][j+]+=f[y][j];
         }
     } ans+=g[x][];return ;
 } int main(){
     scanf("%d",&n);
     for(int i=,x,y;i<n;i++)
     scanf("%d%d",&x,&y),add(x,y);
     dfs(,);f[]=id;id+=d[]*;g[]=id;id+=d[]*;
     solve(,);printf("%lld\n",ans);return ;
 }

长链剖分

接下来是WC2010重建计划

　　其实这道题可以说是点分治界的一道神题，可是用长剖也可以做，但是并不是特别主流的做法。这个如果我们dp出局部的答案，还是需要对一个区间的状态取最优的，所以我们想到了用线段树来记状态，区间取max直接维护就好，然后需要继承一些东西的时候，我们不能用指针轻易的完成这个操作了，所以我们只好借助dfs序搞出偏移量即可。

　　为什么把这道题放在这个位置，首先因为它综合了其他算法，此外还是因为他的细节很多，容易手残写错，可以献给大家练习代码能力。（我的代码不知道出了什么鬼，就是不能开O2，一开O2就全T要么就全RE，不过比点分治短就是了）

代码：

 #include<bits/stdc++.h>
 #define db double
 using namespace std;
 const int N=;
 struct node{int y,z,nxt;}e[N];
 int L,U,n,son[N];double p,f[N],g[N],ans;
 int h[N],ww[N],d[N],pos[N],tot,c,rt,cnt,lm;
 struct segt{int l,r,ls,rs;db s;}t[N*];
 void add(int x,int y,int z){
     e[++c]=(node){y,z,h[x]};h[x]=c;
     e[++c]=(node){x,z,h[y]};h[y]=c;
 } void pushup(int x){
     int ls=t[x].ls,rs=t[x].rs;
     t[x].s=max(t[ls].s,t[rs].s);
 } void build(int x,int l,int r){
     if(l==r){t[x]=(segt){l,r,-,-,-1e10};return ;}
     int mid=l+r>>;t[x].l=l;t[x].r=r;
     t[x].ls=++cnt;t[x].rs=++cnt;
     build(t[x].ls,l,mid);build(t[x].rs,mid+,r);
 } void clear(int x){
     t[x].s=1e-;
     if(~t[x].ls) clear(t[x].ls);
     if(~t[x].rs) clear(t[x].rs);
 } db update(int x,int k,db c){
     if(t[x].r==t[x].l) return t[x].s=max(t[x].s,c);
     int mid=t[x].l+t[x].r>>;
     if(k<=mid) update(t[x].ls,k,c);
     else update(t[x].rs,k,c);pushup(x);
 } db query(int x,int l,int r){
     if(l<=t[x].l&&t[x].r<=r)
     return t[x].s;db re=-1e18;
     int mid=t[x].l+t[x].r>>;
     if(l<=mid) re=max(re,query(t[x].ls,l,r));
     if(mid<r) re=max(re,query(t[x].rs,l,r));
     return re;
 } void dfs(int x,int fa,int v){
     d[x]=;for(int i=h[x],y;i;i=e[i].nxt)
     if((y=e[i].y)!=fa){
         dfs(y,x,e[i].z);
         d[x]=max(d[x],d[y]+);
         if(d[y]>d[son[x]])
         son[x]=y,ww[x]=e[i].z;
     } return ;
 } void solve(int x,int fa){
     if(!pos[x]) pos[x]=++tot;
     int u=pos[x];g[u]=f[u]=;//u是x在dfs序中的位置
     if(son[x]) solve(son[x],x),//v是y在dfs序中的位置
     g[u]+=g[u+]+ww[x]-p,f[u]=-g[u];
     update(rt,u,f[u]);
     for(int i=h[x],y;i;i=e[i].nxt)
     if((y=e[i].y)!=fa&&y!=son[x]){
         solve(y,x);int v=pos[y],z=e[i].z;
         for(int j=;j<=d[y];j++)
         if(L-j<d[x]){
             db q=query(rt,u+max(,L-j),
             u+min(U-j,d[x]-));
             ans=max(ans,z-p+f[v+j-]+g[v]+g[u]+q);
         } for(int j=;j<=d[y];j++)
         if(z-p+f[v+j-]+g[v]>g[u]+f[u+j])
         f[u+j]=z-p+f[v+j-]+g[v]-g[u],
         update(rt,u+j,f[u+j]);
     } if(d[x]->=L) ans=max(ans,g[u]+
     query(rt,u+L,u+min(U,d[x]-)));
 } bool pd(db x){
     clear(rt);p=x;
     ans=-1e18;solve(,);
     return ans>=;
 } int main(){ rt=++cnt;
     scanf("%d%d%d",&n,&L,&U);build(rt,,n);
     for(int i=,x,y,z;i<n;i++)
     scanf("%d%d%d",&x,&y,&z),
     add(x,y,z),lm=max(lm,z);
     dfs(,,);db l=,r=lm;
     while(r-l>1e-){
         db mid=(l+r)/2.0;
         if(pd(mid)) l=mid;
         else r=mid;
     } printf("%.3lf\n",l);return ;
 }

长链剖分

这种算法我们就讨论到这里，其实还有不少其他的题目，希望大家有余力可以多加练习。