@codeforces - 932F@ Escape Through Leaf

Posted 2020-11-23 tiw-air-oao

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

给定一个 n 个点的树（标号1~n），以结点 1 为根。每个结点有两个点权 ai 与 bi。

你可以从一个点出发跳到它的子树中的某个结点去（不能跳到自己）。
从 x 跳到 y 所花费的代价为 ax * by，跳跃的总代价为每次跳跃的代价之和。

对于每个结点，计算从它出发跳到某一叶子结点的最小代价和。

Input
第一行包含一个整数 n (2?≤?n?≤?10^5)，表示树中的结点数量。
第二行包含 n 个整数 a1, a2, ..., an (-10^5≤ai≤10^5)。
第三行包含 n 个整数 b1, b2, ..., bn (-10^5≤bi≤10^5)。
接下来 n-1 行每行包含两个整数 ui 和 vi (1≤ui, vi≤n)，描述了树中的一条边。

Output
输出 n 个空格分开的整数，第 i 个描述了从第 i 个结点跳到叶子结点的最小代价和。

Examples
Input
3
2 10 -1
7 -7 5
2 3
2 1
Output
10 50 0

Input
4
5 -10 5 7
-8 -80 -3 -10
2 1
2 4
1 3
Output
-300 100 0 0

@solution@

本题方法很多，可以转成 dfs 序然后写 cdq 分治，可以写平衡树在树上启发式合并维护凸包，也可以像我一开始一样转成 dfs 序分块维护凸包（它竟然没有 TLE。。。令我颇感意外）。
在这里介绍一个不那么传统的方法吧：我们使用李超树 + 线段树合并。

首先不难写出 dp 式 dp[x] = min(dp[c] + ax*bc)，发现它是斜率优化的形式。
处理斜率优化问题，除了传统的方法将其看作凸包以外，其实还有李超线段树的方法。
我们记 bc 为斜率，dp[c] 为截距，ax 为横坐标，可以通过李超线段树找到最小值（可自行百度）。

类比于平衡树的启发式合并，我们可以直接用经典的线段树合并，在树上对李超线段树进行合并操作。
与平常的线段树合并不同的是，当两棵线段树的结点同时都含有直线标记，要将一个直线标记插入到另一棵线段树中。

复杂度感觉像是 O(nlogn)？每个直线标记最多在线段树中被下放 log 次，而线段树合并的复杂度 <= 一个一个将结点插入的复杂度。
但是感觉跑起来没有 O(nlogn) 那么快？不是很清楚是常数问题还是时间复杂度证错了。

@accepted code@

#include <cmath>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int MAXN = 100000;
const ll INF = (1LL<<60);
struct line{
    ll k, b;
    line(ll _k=0, ll _b=0) : k(_k), b(_b) {}
    ll get(ll x) {return k * x + b;}
};
ll a[MAXN + 5], b[MAXN + 5], f[MAXN + 5];
struct segtree{
    struct node{
        line l;
        node *ch[2];
    }pl[60*MAXN + 5], *ncnt, *NIL;
    segtree() {
        NIL = ncnt = pl;
        NIL->ch[0] = NIL->ch[1] = NIL;
    }
    node *newnode(line l) {
        node *p = (++ncnt);
        p->ch[0] = p->ch[1] = NIL, p->l = l;
        return p;
    }
    void insert(node *&rt, int l, int r, line ln) {
        if( rt == NIL ) {
            rt = newnode(ln);
            return ;
        }
        int m = (int)floor(1.0*(l + r)/2);
        if( rt->l.get(l) > ln.get(l) ) swap(rt->l, ln);
        if( rt->l.get(m) > ln.get(m) )
            swap(rt->l, ln), insert(rt->ch[0], l, m, ln);
        else if( rt->l.get(r) > ln.get(r) )
            insert(rt->ch[1], m + 1, r, ln);
    }
    ll query(node *rt, int l, int r, ll p) {
        if( rt == NIL ) return INF;
        if( l == r ) return rt->l.get(p);
        int m = (int)floor(1.0*(l + r)/2);
        if( p <= m ) return min(rt->l.get(p), query(rt->ch[0], l, m, p));
        else return min(rt->l.get(p), query(rt->ch[1], m + 1, r, p));
    }
    node *merge(node *rt1, node *rt2, int l, int r) {
        if( rt1 == NIL ) return rt2;
        if( rt2 == NIL ) return rt1;
        int m = (int)floor(1.0*(l + r)/2);
        rt1->ch[0] = merge(rt1->ch[0], rt2->ch[0], l, m);
        rt1->ch[1] = merge(rt1->ch[1], rt2->ch[1], m + 1, r);
        insert(rt1, l, r, rt2->l);
        return rt1;
    }
}T;
struct edge{
    int to; edge *nxt;
}edges[2*MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
    edge *p = (++ecnt);
    p->to = v, p->nxt = adj[u], adj[u] = p;
    p = (++ecnt);
    p->to = u, p->nxt = adj[v], adj[v] = p;
}
segtree::node *rt[MAXN + 5];
void dfs(int x, int fa) {
    rt[x] = T.NIL;
    for(edge *p=adj[x];p;p=p->nxt)
        if( p->to != fa )
            dfs(p->to, x), rt[x] = T.merge(rt[x], rt[p->to], -MAXN, MAXN);
    if( rt[x] == T.NIL ) f[x] = 0;
    else f[x] = T.query(rt[x], -MAXN, MAXN, a[x]);
    T.insert(rt[x], -MAXN, MAXN, line(b[x], f[x]));
}
int main() {
    int n; scanf("%d", &n);
    for(int i=1;i<=n;i++) scanf("%lld", &a[i]);
    for(int i=1;i<=n;i++) scanf("%lld", &b[i]);
    for(int i=1;i<n;i++) {
        int u, v; scanf("%d%d", &u, &v);
        addedge(u, v);
    }
    dfs(1, 0);
    for(int i=1;i<=n;i++) printf("%lld%c", f[i], i == n ? '
' : ' ');
}

@details@

现在只写了分块维护凸包与李超线段树合并两种方法。

有时间（咕咕咕）练一下另外两种吧。