LOJ#2249 购票

解：转移方程写出来，发现是斜率优化。因为在树上，考虑CDQ分治 + 点分治的方法...

每次找到重心，然后先递归解决上面的子树。然后把上面子树的凸包搞出来，下面每个点在凸包上二分找最优决策。

重心自己不参与上面子树的递归，单独给下面转移。

注意这个东西斜率可能有负数，不能简单乘到不等式另一边。

二分的写法要注意。

每个点的转移还有个深度限制，所以要按照深度限制把询问(待转移的点)排序，然后一边动态加凸包一边二分回答询问。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 200010, INF = 0x3f3f3f3f;
const double eps = 1e-12;

struct Edge {
    int nex, v;
    LL len;
}edge[N << 1]; int tp = 1;

int e[N], _n, root, small, siz[N], deep[N], fa[N], stk[N], top2, stk2[N], SMALL, n;
LL p[N], q[N], lim[N], d[N], f[N];
bool del[N];

inline bool cmp_l(const int &a, const int &b) {
    return lim[a] < lim[b];
}

template <class T> inline void Min(T &a, const T &b) {
    a > b ? a = b : 0;
    return;
}

inline void add(int x, int y, LL z) {
    tp++;
    edge[tp].v = y;
    edge[tp].len = z;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS_1(int x, int f) {
    deep[x] = deep[f] + 1;
    fa[x] = f;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) continue;
        d[y] = d[x] + edge[i].len;
        DFS_1(y, x);
    }
    return;
}

void getroot(int x, int f) {
    //printf("getroot : %d  %d 
", x, f);
    int large = 0;
    siz[x] = 1;
    Min(SMALL, deep[x]);
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(del[y] || y == f) continue;
        getroot(y, x);
        siz[x] += siz[y];
        if(siz[y] > large) large = siz[y];
    }
    large = std::max(large, _n - siz[x]);
    if(small > large) {
        small = large;
        root = x;
    }
    return;
}

void DFS_2(int x, int f) {
    stk2[++top2] = x;
    //printf("DFS2 : %d 
", x);
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(del[y] || y == f) continue;
        DFS_2(y, x);
    }
    return;
}

inline bool check(int a, int b, int c) {
    return (long double)(f[b] - f[a]) / (d[b] - d[a]) + eps > (long double)(f[c] - f[b]) / (d[c] - d[b]);
}

void DFS_3(int x, int f) {
    siz[x] = 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(del[y] || y == f) continue;
        DFS_3(y, x);
        siz[x] += siz[y];
    }
    return;
}

void DFS_4(int x, int father, int rt) {
    if(x != rt && d[rt] >= lim[x]) {
        Min(f[x], f[rt] - p[x] * d[rt]);
        /*if(x == 5) {
            printf("f %d = %lld rt = %d 
", x, f[x], rt);
        }*/
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == father || del[y]) continue;
        DFS_4(y, x, rt);
    }
    return;
}

void CDQ(int x) {

    //printf("CDQ : %d _n = %d 
", x, _n);

    if(_n == 1) {
        f[x] += p[x] * d[x] + q[x];
        del[x] = 1;
        //printf("1 : f [ %d ] = %lld 
", x, f[x]);
        return;
    }

    SMALL = small = INF;
    getroot(x, 0);
    int tempsmall = SMALL;
    x = root;
    DFS_3(x, 0);
    del[x] = 1;
    ///
    if(del[fa[x]]) {
        f[x] += p[x] * d[x] + q[x];

        //printf("2 : f [ %d ] = %lld 
", x, f[x]);

        DFS_4(x, 0, x);
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(del[y]) continue;
            _n = siz[y];
            CDQ(y);
        }
        return;
    }
    _n = siz[fa[x]];
    CDQ(fa[x]);

    /**
        while(top > 1 && check(stk[top - 1], stk[top], temp)) {
            top--;
        }
    */
    top2 = 0;
    DFS_2(x, 0);
    std::sort(stk2 + 1, stk2 + top2 + 1, cmp_l);
    std::reverse(stk2 + 1, stk2 + top2 + 1);
    int pos = fa[x], top = 0;
    //printf(" ----------------- x = %d fa[x] = %d 
", x, fa[x]);
    /*printf("sort : ");
    for(int i = 1; i <= top2; i++) {
        printf("%d ", stk2[i]);
    }
    puts("");*/
    for(int i = 1; i <= top2; i++) {
        int xx = stk2[i];
        while(pos && deep[pos] >= tempsmall && d[pos] >= lim[xx]) {
            /// insert p
            while(top > 1 && check(pos, stk[top], stk[top - 1])) {
                top--;
            }
            stk[++top] = pos;
            //printf("insert pos = %d 
", pos);
            pos = fa[pos];
        }
        if(!top) continue;
        int l = 1, r = top;
        //printf("l = %d r = top = %d 
", l, r);
        while(l < r) {
            int mid = (l + r) >> 1;
            //printf("mid = %d 
", mid);
            if(l < mid && p[xx] > (long double)(f[stk[mid]] - f[stk[mid - 1]]) / (d[stk[mid]] - d[stk[mid - 1]])) {
                r = mid - 1;
            }
            else if(mid < r && p[xx] < (long double)(f[stk[mid + 1]] - f[stk[mid]]) / (d[stk[mid +1]] - d[stk[mid]])) {
                //printf("-------------- %lld * %lld < %lld 
", p[xx], (d[stk[mid +1]] - d[stk[mid]]), (f[stk[mid + 1]] - f[stk[mid]]));
                l = mid + 1;
            }
            else {
                r = mid;
                break;
            }
        }
        //printf("r = %d 
", r);
        /// branch search OVER
        //printf("Min %lld (%lld - %lld * %lld) 
", f[xx], f[stk[r]], p[xx], d[stk[r]]);
        Min(f[xx], f[stk[r]] - p[xx] * d[stk[r]]);
        //printf("%d -> %d  f[%d] = %lld 
", stk[r], xx, xx, f[xx]);
    }

    f[x] += p[x] * d[x] + q[x];
    DFS_4(x, 0, x);
    //printf("3 : f [ %d ] = %lld  += %lld * %lld + %lld 
", x, f[x], p[x], d[x], q[x]);

    /// rest
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(del[y]) continue;
        _n = siz[y];
        CDQ(y);
    }
    return;
}

int main() {

    freopen("in.in", "r", stdin);
    //freopen("my.out", "w", stdout);

    memset(f, 0x3f, sizeof(f));
    f[1] = 0;
    int ttt; LL z;
    scanf("%d%d", &n, &ttt);
    for(int i = 2, x; i <= n; i++) {
        scanf("%d%lld%lld%lld%lld", &x, &z, &p[i], &q[i], &lim[i]);
        add(x, i, z); add(i, x, z);
    }
    /// input over
    DFS_1(1, 0);
    for(int i = 2; i <= n; i++) {
        lim[i] = std::max(0ll, d[i] - lim[i]);
    }

    //printf("OVER 
");

    _n = n;
    CDQ(1);

    for(int i = 2; i <= n; i++) {
        printf("%lld
", f[i]);
    }
    return 0;
}