【BZOJ 3672】[Noi2014]购票 树分治+斜率优化

好了，回来填这个坑，闲来无事就尽力说清楚一些吧，code较难的部分我加了注释。

首先让我们考虑如果题目要求的不是一个树形结构，而是线性的我们怎么来处理。（其实就变成了一道水水的斜率优化dp），至少这个方程还是很好化简的，假设k<j而且f[k]比f[j]更优，满足(f[k]-f[j])/(dis[k]-dis[j])>p[i]的斜率方程式，但是我们会吃惊的发现，不等式左边x是单调的，但是不等式的右边斜率并不单调（p值给定，p[k]可以比p[j]大，也可以小），也就是说，在维护单调队列的时候，我们当然希望不等式左边越大越好，但是当前满足的斜率后面不一定满足，这里有点抽象，实际就是单调队列的右指针可以++或者--但是左指针却不能向右移动，还是一个半凸包，然后每次找最优的转移的时候，二分斜率找到最后一个斜率大于p[i]的点用它来转移。（其实即使一边不单调还是很水啦，重要的是接下来的怎么套树分治）。

首先需要明确的是，一棵树其实就是很多的链组成的对吧，也就是说，可以先思考暴力怎么求，把树的根节点到每一个叶子节点都当成一个线性的链状结构，分别求解，然后会发现其实有很多部分都是重复了的，例如i节点个j节点的公共祖先到根节点之间的链其实对他们的影响都是一样的，却被重复计算了。所以树分治的思想就出来了，在处理一颗子树的时候，我先找到它的重心，然后用重心到根节点之间的影响去更新它的子树的答案。那好，又怎么来获得这个重心到根节点之间的答案呢，一个想法就是直接暴力算，但是既然是树分治，还有想法就是把这个节点和根继续分治求解，然后再倒回来求其他子树的解，所以就是：

1.处理当前子树

2.找当前子树的重心

3.一起分治重心和根节点

3.得到根节点到子树重心之间链的答案

4.用这个答案来更新重心其他子树的ans

5.继续分治重心的其他子树

注意，一定要分清楚重心和根节点的区别。总之这道题让我对树分治和斜率优化dp都有了一个更深的理解，就作为一道例题把。

    #include<cstdio>  
    #include<cstring>  
    #include<iostream>  
    #include<algorithm>  
    #define maxn 200020*2  
    #define LL long long  
    using namespace std;  
    int n,fa[maxn],q[maxn*2],sta[maxn*2],size,head[maxn],ff[maxn],cnt,tot,sum[maxn],rt,vis[maxn];  
    LL f[maxn],p_v[maxn],q_v[maxn],l_v[maxn],dis[maxn];  
    double slp[maxn*2];  
    struct edge{int v,next;LL w;}e[maxn*2];  
    void adde(int a,int b,LL c){e[tot].v=b,e[tot].w=c,e[tot].next=head[a];head[a]=tot++;}  
    bool cmp(const int& a,const int& b){return dis[a]-l_v[a]>dis[b]-l_v[b];}  
      
    void getrt(int u){  
        ff[u]=0,sum[u]=1;  
        for(int v,i=head[u];i!=-1;i=e[i].next){  
            if(vis[v=e[i].v])continue;  
            getrt(v);  
            sum[u]+=sum[v];  
            ff[u]=max(ff[u],sum[v]);  
        }  
        ff[u]=max(ff[u],size-ff[u]);  
        if(ff[u]<ff[rt])rt=u;  
    }  
      
    double getk(int a,int b){return (double)(f[a]-f[b])/(dis[a]-dis[b]);}  
    void dfs(int u){  
        sta[++cnt]=u;  
        for(int v,i=head[u];i!=-1;i=e[i].next){  
            if(vis[v=e[i].v])continue;  
            dfs(v);  
        }  
    }  
    void query(int x,int l,int r){//二分斜率   
        while(l<r){  
            int mid=l+r>>1;  
            if(slp[mid]>=p_v[x])l=mid+1;  
            else r=mid;  
        }  
        f[x]=min(f[x],f[q[l]]+(dis[x]-dis[q[l]])*p_v[x]+q_v[x]);  
    }  
      
    void solve(int u){  
        ff[rt=0]=1e9;  
        getrt(u);  
        int x=rt;vis[x]=1;//找到当前节点为根的子树的重心，并且处理这个重心  
        if(x!=u){//不重合，说明需要处理这个重心到根节点这条链之间的祖先的关系   
            size=sum[u]-sum[x];//处理这一条链以及链上的一些其他的奇奇怪怪的子树   
      
            solve(u);//继续处理这棵树，但是此时的子树是已经不包含x了的其余的子树   
            cnt=0;dfs(x);//此时我们得到了重心和根节点之间的链的关系，所以用这条链来更新重心的其他子树的dp值   
            sort(sta+1,sta+1+cnt,cmp);//按能够到达节点的深度从大到小排序   
              
            int i=1,y=fa[x],r=1;q[1]=y;  
            while(i<=cnt&&dis[sta[i]]-l_v[sta[i]]>dis[y])i++;  
              
            for(;i<=cnt;i++){//深度减上去   
                while(y!=u&&dis[sta[i]]-dis[fa[y]]<=l_v[sta[i]]){//还能够向上走   
                    y=fa[y];  
                    while(r>1&&getk(q[r-1],q[r])<=getk(q[r],y))r--;//加入一个新的元素，剔除不会更优的元素   
                    slp[r]=getk(q[r],y),q[++r]=y;  
                }  
                query(sta[i],1,r);//跟新这个节点的dp值    
            }  
        }else cnt=0,dfs(x);//重心和根节点之间没有链了   
        for(int i=1;i<=cnt;i++)if(dis[sta[i]]-dis[x]<=l_v[sta[i]])  
            f[sta[i]]=min(f[sta[i]],f[x]+(dis[sta[i]]-dis[x])*p_v[sta[i]]+q_v[sta[i]]);  
        for(int i=head[x];i!=-1;i=e[i].next){  
            if(vis[e[i].v])continue;  
            size=sum[e[i].v];solve(e[i].v);  
        }  
    }  
      
    int main(){  
        memset(head,-1,sizeof(head));int t;  
        scanf("%d%d",&n,&t);LL x;  
        for(int i=2;i<=n;i++){  
            scanf("%d%lld%lld%lld%lld",fa+i,&x,p_v+i,q_v+i,l_v+i);  
            adde(fa[i],i,x);  
            dis[i]=dis[fa[i]]+x;  
        }  
        memset(f,0x3f,sizeof(f));f[1]=0;  
        size=n;  
        solve(1);  
        for(int i=2;i<=n;i++)printf("%lld\n",f[i]);  
        return 0;  
    }