BZOJ 3672 [Noi2014]购票 （熟练剖分+凸壳维护）

题目链接：http://www.lydsy.com:808/JudgeOnline/problem.php?id=3672

题意：给出一棵有根树（1为根），边有长度。每个点u有三个属性（len[u],p[u],q[u]）,每次u可以转移到u的某个祖先节点v（v满足dist(u,v)<=len[u]）,代价为p[u]*dist(u,v)+q[u]。求每个点都转移到1的代价。

思路：首先设f[u]表示u转移到1的最小代价，那么我们可以得到一个DP方程： f[u]=min(f[v]+p[u]*(s[u]-s[v])+q[u]) (v为u的祖先节点,s[u]表示u到根节点1的距离，s[u]-s[v]<=len[u])。

将上面的式子变形：f[u]=(-s[v]*p[u]+f[v])+(s[u]*p[u]+q[u])。其中s[u]*p[u]+q[u]对于u为定值那么我们只要求-s[v]*p[u]+f[v]的最小值即可。

我们按照深度由小大到的顺序依次计算，那么计算u时，它的所有祖先节点都已经计算过，他们的f[v]和s[v]值都已经知道。那么，我们断然是不能一个一个枚举u的所有祖先的.因此如何维护呢？设k=-s[v],b=f[v]，x=p[u]，y=kx+b，我们现在就是求y的最小值，k<0，斜率k，y轴截距b。我们发现，只要维护[1,fa[u]]这些点组成的上凸壳即可。

我们设现在已经维护了一个上凸壳，现在加入一个点(-s[t],f[t])，我们发现，由于题目说边的距离严格大于0，那么这个s[t]是严格递增的，也就是斜率越来越趋近于负无穷，因此，我们首先将其加入到已经维护的凸壳的最后即可（当x很大时一定是这个新加入的能够使得答案最小）。此时，前面可能有一些不再是最优值，我们只要依次从后向前判断，不是最优值就删掉，因此用一个vector维护即可（不用splay、set什么的了）。

因此，我们得到算法：

（1）首先，树链剖分，用线段树维护每个链，线段树每个节点用一个vector维护这个区间的点组成的上凸壳

（2）按照深度由小到大依次计算。由于这里有一个距离限制，那么对于u，最后我们需要查询的是一段区间[v,fa[u]]，v是满足s[u]-s[v]<=len[u]的深度最小的u的祖先。

（3）计算完节点u后将其插入到线段树中包含该点的所有区间。

const i64 inf=(1LL<<62);
const int mod=1000000007;
const int N=200005;
 
vector<int > g[N];
int n,t;
int fa[N];
i64 len[N],p[N],q[N],dis[N];
 
int sonNum[N];
int dep[N];
 
i64 s[N];
 
void DFS(int u)
{
    sonNum[u]=1;
    int i;
    for(i=0;i<SZ(g[u]);i++)
    {
        int v=g[u][i];
        dep[v]=dep[u]+1;
        s[v]=s[u]+dis[v];
        DFS(v);
        sonNum[u]+=sonNum[v];
    }
}
 
int id,belong[N],pos[N],mp[N];
 
void dfs(int u,int root)
{
    id++;
    belong[u]=root;
    pos[u]=id;
    mp[id]=u;
    int i,k=n+1;
    for(i=0;i<SZ(g[u]);i++) if(sonNum[k]<sonNum[g[u][i]]) k=g[u][i];
    if(k==n+1) return;
    dfs(k,root);
    for(i=0;i<SZ(g[u]);i++)
    {
        if(g[u][i]!=k) dfs(g[u][i],g[u][i]);
    }
}
 
struct node
{
    int L,R;
    vector<pair<i64,i64> > root;
};
 
node A[N<<2];
 
void build(int t,int L,int R)
{
    A[t].L=L;
    A[t].R=R;
    A[t].root.clear();
    if(L==R)
    {
        return;
    }
    int M=(L+R)>>1;
    build(t<<1,L,M);
    build(t<<1|1,M+1,R);
}
 
#define pdd pair<i64,i64>
 
i64 f[N];
 
double cross(pdd a,pdd b)
{
    return 1.0*(a.second-b.second)/(b.first-a.first);
}
 
int sgn(double x)
{
	if(x>1e-20) return 1;
	if(x<-1e-20) return -1;
	return 0;
}
 
void add(vector<pair<i64,i64> > &x,i64 s,i64 f)
{
    pdd p3=MP(s,f);
    while(SZ(x)>=2)
    {
        pdd p2=x[SZ(x)-1];
        pdd p1=x[SZ(x)-2];
        double x1=cross(p2,p3);
        double x2=cross(p1,p3);
        if(sgn(x1-x2)==1) break;
        x.pop_back();
    }
	if(SZ(x)==1&&f<=x[0].second)  x.pop_back();
    x.pb(p3);
}
 
void add(int t,int pos,i64 s,i64 f)
{
    add(A[t].root,s,f);
    if(A[t].L==A[t].R) return;
    int M=(A[t].L+A[t].R)>>1;
    if(pos<=M) add(t<<1,pos,s,f);
    else add(t<<1|1,pos,s,f);
}
 
i64 curX;
 
i64 get(vector<pdd> x)
{
    int L=0,R=SZ(x)-1;
    while(R-L>=4)
    {
        int M=(R+L)>>1;
        double xx=cross(x[M-1],x[M]);
        if(sgn(xx-curX)>=0) R=M;
        else L=M;
    }
    i64 ans=inf;
    int i;
    for(i=L;i<=R;i++)
    {
        pdd p=x[i];
        i64 tmp=curX*p.first+p.second;
        if(tmp<ans) ans=tmp;
    }
    return ans;
}
 
i64 cal(int t,int L,int R,i64 len)
{
    if(A[t].L==L&&A[t].R==R)
    {
        int u1=mp[L];
        int u2=mp[R];
        if(s[u2]-s[u1]<=len) return get(A[t].root);
 
        int M=(A[t].L+A[t].R)>>1;
        i64 ans=cal(t<<1|1,M+1,R,len);
        u1=mp[A[t<<1].R];
        len-=(s[u2]-s[u1]);
        if(len<0) return ans;
        i64 tmp=cal(t<<1,L,M,len);
        if(tmp<ans) ans=tmp;
        return ans;
    }
    else
    {
        int M=(A[t].L+A[t].R)>>1;
        if(R<=M) return cal(t<<1,L,R,len);
        if(L>M) return cal(t<<1|1,L,R,len);
        i64 ans=cal(t<<1|1,M+1,R,len);
        int u1=mp[A[t<<1].R];
        int u2=mp[R];
        len-=(s[u2]-s[u1]);
        if(len<0) return ans;
 
        i64 tmp=cal(t<<1,L,M,len);
        if(tmp<ans) ans=tmp;
        return ans;
    }
}
 
i64 cal(int u)
{
    curX=p[u];
    i64 L=len[u];
    i64 ans=inf;
    while(L>=0)
    {
        i64 tmp=cal(1,pos[belong[u]],pos[u],L);
        if(tmp<ans) ans=tmp;
        if(fa[belong[u]]==0) break;
        L-=(s[u]-s[fa[belong[u]]]);
		u=fa[belong[u]];
    }
    return ans;
}
 
int main()
{
    scanf("%d%d",&n,&t);
    int i;
    for(i=2;i<=n;i++)
    {
        scanf("%d%lld%lld%lld%lld",&fa[i],&dis[i],&p[i],&q[i],&len[i]);
        g[fa[i]].pb(i);
    }
    DFS(1);
    dfs(1,1);
    build(1,1,n);
    add(1,pos[1],0,0);
    for(i=2;i<=n;i++)
    {
        int u=mp[i];
        f[u]=cal(u)+p[u]*s[u]+q[u];
        add(1,pos[u],-s[u],f[u]);
    }
    for(i=2;i<=n;i++) printf("%lld\n",f[i]);
}