3672: [Noi2014]购票 树剖+线段树+斜率优化

Description

今年夏天，NOI在SZ市迎来了她30周岁的生日。来自全国 n 个城市的OIer们都会从各地出发，到SZ市参加这次盛会。
全国的城市构成了一棵以SZ市为根的有根树，每个城市与它的父亲用道路连接。为了方便起见，我们将全国的 n 个城市用 1 到 n 的整数编号。其中SZ市的编号为 1。对于除SZ市之外的任意一个城市 v，我们给出了它在这棵树上的父亲城市 fv 以及到父亲城市道路的长度 sv。
从城市 v 前往SZ市的方法为：选择城市 v 的一个祖先 a，支付购票的费用，乘坐交通工具到达 a。再选择城市 a 的一个祖先 b，支付费用并到达 b。以此类推，直至到达SZ市。
对于任意一个城市 v，我们会给出一个交通工具的距离限制 lv。对于城市 v 的祖先 a，只有当它们之间所有道路的总长度不超过 lv 时，从城市 v 才可以通过一次购票到达城市 a，否则不能通过一次购票到达。对于每个城市 v，我们还会给出两个非负整数 pv,qv 作为票价参数。若城市 v 到城市 a 所有道路的总长度为 d，那么从城市 v 到城市 a 购买的票价为 dpv+qv。
每个城市的OIer都希望自己到达SZ市时，用于购票的总资金最少。你的任务就是，告诉每个城市的OIer他们所花的最少资金是多少。

Input

第 1 行包含2个非负整数 n,t，分别表示城市的个数和数据类型（其意义将在后面提到）。输入文件的第 2 到 n 行，每行描述一个除SZ之外的城市。其中第 v 行包含 5 个非负整数 f_v,s_v,p_v,q_v,l_v，分别表示城市 v 的父亲城市，它到父亲城市道路的长度，票价的两个参数和距离限制。请注意：输入不包含编号为 1 的SZ市，第 2 行到第 n 行分别描述的是城市 2 到城市 n。

Output

输出包含 n-1 行，每行包含一个整数。其中第 v 行表示从城市 v+1 出发，到达SZ市最少的购票费用。同样请注意：输出不包含编号为 1 的SZ市。

Sample Input

7 3

1 2 20 0 3

1 5 10 100 5

2 4 10 10 10

2 9 1 100 10

3 5 20 100 10

4 4 20 0 10

Sample Output

40

150

70

149

300

150

题解

据说这题有nlog^2的做法，但是我还是太菜了，乖乖去写nlog^3，我们先树剖一下，对于每个点我们求出它最上面可以从哪个点过来，然后提取出这logn条链，在线段树每个节点上维护一个凸包，然后找到每条链所对应的logn个区间，分别在凸壳二分一下求出最优点，取最小值即可。

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<ctime>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
#include<iomanip>
#include<vector>
using namespace std;
#define INF 1e100
int siz[400000];
int son[400000];
int fa[400000][18];
long long deep[400000];
int f[400000];
int dfsx[400000];
int wz[400000];
struct bian
{
    int l,r;
    long long v;
}a[400100];
int fir[400010];
int nex[400010];
int top[400010];
int tot=1;
void add_edge(int l,int r,long long v)
{
    a[++tot].l=l;
    a[tot].r=r;
    a[tot].v=v;
    nex[tot]=fir[l];
    fir[l]=tot;
}
void dfs1(int u,int fro)
{
    fa[u][0]=fro;
    siz[u]=1;
    son[u]=0;
    for(int o=fir[u];o;o=nex[o])
    {
        deep[a[o].r]=deep[u]+a[o].v;
        dfs1(a[o].r,u);
        if(siz[a[o].r]>siz[son[u]]) son[u]=a[o].r;
        siz[u]+=siz[a[o].r];
    }
}
int id=0;
void dfs2(int u,int fro)
{
    dfsx[++id]=u;
    wz[u]=id;
    if(u==son[fa[u][0]]) top[u]=top[fa[u][0]];
    else top[u]=u;
    if(son[u]) dfs2(son[u],u);
    for(int o=fir[u];o;o=nex[o])
    {
        if(a[o].r==son[u]) continue;
        dfs2(a[o].r,u);
    }
}
struct point
{
    long long x,y;
    point(){}
    point(long long _,long long __):x(_),y(__){}
    long double operator * (point b)
    {
        if(x==b.x) return y<b.y?INF:-INF;
        long double yy=y-b.y;
        long double xx=x-b.x;
        return yy/xx;
    }
};
void Insert(vector<point> &v,point p)
{
    int siz=v.size();
    if(siz>=1 && v[siz-1].x>p.x) return;
    while(siz>1 && v[siz-2]*v[siz-1]>v[siz-1]*p) siz--,v.pop_back();
    v.push_back(p);
}
namespace Seg
{
    struct xianduan
    {
        int l,r;
        vector<point> hull;
    }a[530000];
    void make_tree(int o,int l,int r)
    {
        a[o].l=l;
        a[o].r=r;
        if(l==r) return;
        int mid=l+r>>1;
        make_tree(2*o,l,mid);
        make_tree(2*o+1,mid+1,r);
    }
    point get_minn(int o,long long p)
    {
        int siz=a[o].hull.size();
        if(siz==0) return point(-2147483647,-1);
        if(siz==1) return a[o].hull[0];
        if(p<a[o].hull[0]*a[o].hull[1]) return a[o].hull[0];
        if(p>a[o].hull[siz-2]*a[o].hull[siz-1]) return a[o].hull[siz-1];
        int l=1,r=siz-2;
        int jilu=1;
        while(l<=r)
        {
            int mid=l+r>>1;
            if(a[o].hull[mid-1]*a[o].hull[mid]<p) jilu=mid,l=mid+1;
            else r=mid-1;
        }
        point mid=a[o].hull[jilu];
        return mid;
    }
    long long get_minn(int o,int l,int r,long long p)
    {
        if(a[o].r<l || a[o].l>r) return (long long)1e18;
        if(a[o].l>=l && a[o].r<=r)
        {
            point mid=get_minn(o,p);
            if(mid.x==-2147483647) return 1e18;
            return mid.y-mid.x*p;
        }
        return min(get_minn(2*o,l,r,p),get_minn(2*o+1,l,r,p));
    }
    void Insert(int o,int wz,point p)
    {
        if(a[o].r<wz || a[o].l>wz) return;
        Insert(a[o].hull,p);
        if(a[o].l==a[o].r) return;
        Insert(2*o,wz,p);
        Insert(2*o+1,wz,p);
    }
}
long long get_maxx(int x,int y,long long p)
{
    long long re=1e18;
    while(top[x]!=top[y])
    {
        if(deep[top[x]]<deep[top[y]]) swap(x,y);
        re=min(re,Seg::get_minn(1,wz[top[x]],wz[x],p));
        x=fa[top[x]][0];
    }
    if(deep[x]<deep[y]) swap(x,y);
    re=min(re,Seg::get_minn(1,wz[y],wz[x],p));
    return re;
}
int n,m;
long long p[400000];
long long q[400000];
long long l[400000];
void init()
{
    scanf("%d%d",&n,&m);
    for(int i=2;i<=n;i++)
    {
        long long ll,v;
        scanf("%lld%lld%lld%lld%lld",&ll,&v,&p[i],&q[i],&l[i]);
        add_edge(ll,i,v);
    }
    dfs1(1,0);
    dfs2(1,0);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=17;j++)
            fa[i][j]=fa[fa[i][j-1]][j-1];
    Seg::make_tree(1,1,n);
}
bool flag=false;
long long anss[400000];
void dfs(int u)
{
    if(u==1) Seg::Insert(1,wz[1],point(0,0));
    else
    {
        int x=u;
        for(int i=17;i>=0;i--)
            if(fa[x][i] && deep[fa[x][i]]+l[u]>=deep[u])
                x=fa[x][i];
        long long ans=get_maxx(x,fa[u][0],p[u])+deep[u]*p[u]+q[u];
        Seg::Insert(1,wz[u],point(deep[u],ans));
        anss[u]=ans;
    }
    for(int o=fir[u];o;o=nex[o]) dfs(a[o].r);
}
int main()
{
    init();
    dfs(1);
    printf("%lld\n",anss[2]);
    for(int i=3;i<=n;i++) printf("%lld\n",anss[i]);
    return 0;
}