CF932F Escape Through Leaf [李超树，线段树合并]

奇怪的线段树合并增加了！

朴素的 \(dp\) 是 \(dp_u = \min\{dp_v + a_u \times b_v\} [v \in subtree(u)]\)

然后我们发现这个是一个 \(kx + b\) 的形式，也就是 \(b_v(a_u) + dp_v\)，所以需要的是一个子树信息，子树信息能想到什么？线段树合并？dsu on tree？启发式合并？感觉都能做。

然后的话这里选择了线段树合并，至于朴素的线段树合并，线段树合并的复杂度是 \(n \log n\) 的，证明的话，就考虑 \(f(a + b) = f(a) + f(b) + sz(a \bigcap b)\) 容易发现这边 \(sz(a \bigcap b)\) 不会超过 \(\min\{a,b\}\) 然后证明就很显然了，但是对于李超树合并，需要做的一点是，这个信息不可加，不可减，不可简单合并，所以要把 \(a \bigcap b\) 的部分直接插到树上，复杂度是 \(n \log^2 n\)，所以做完了。

// powered by c++11
// by Isaunoya
#include <bits/stdc++.h>

#define rep(i, x, y) for (register int i = (x); i <= (y); ++i)
#define Rep(i, x, y) for (register int i = (x); i >= (y); --i)

using namespace std;
using db = double;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;

#define pii pair<int, int>
#define fir first
#define sec second

template <class T>

void cmax(T& x, const T& y) {
  if (x < y) x = y;
}

template <class T>

void cmin(T& x, const T& y) {
  if (x > y) x = y;
}

#define all(v) v.begin(), v.end()
#define sz(v) ((int)v.size())
#define pb emplace_back

template <class T>

void sort(vector<T>& v) {
  sort(all(v));
}

template <class T>

void reverse(vector<T>& v) {
  reverse(all(v));
}

template <class T>

void unique(vector<T>& v) {
  sort(all(v)), v.erase(unique(all(v)), v.end());
}

void reverse(string& s) { reverse(s.begin(), s.end()); }

const int io_size = 1 << 23 | 233;
const int io_limit = 1 << 22;
struct io_in {
  char ch;
#ifndef __WIN64
  char getchar() {
    static char buf[io_size], *p1 = buf, *p2 = buf;

    return (p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, io_size, stdin), p1 == p2) ? EOF : *p1++;
  }
#endif
  io_in& operator>>(char& c) {
    for (c = getchar(); isspace(c); c = getchar());

    return *this;
  }
  io_in& operator>>(string& s) {
    for (s.clear(); isspace(ch = getchar());)
      ;

    if (!~ch) return *this;

    for (s = ch; !isspace(ch = getchar()) && ~ch; s += ch)
      ;

    return *this;
  }

  io_in& operator>>(char* str) {
    char* cur = str;
    while (*cur) *cur++ = 0;

    for (cur = str; isspace(ch = getchar());)
      ;
    if (!~ch) return *this;

    for (*cur = ch; !isspace(ch = getchar()) && ~ch; *++cur = ch)
      ;

    return *++cur = 0, *this;
  }

  template <class T>

  void read(T& x) {
    bool f = 0;
    while ((ch = getchar()) < 48 && ~ch) f ^= (ch == 45);

    x = ~ch ? (ch ^ 48) : 0;
    while ((ch = getchar()) > 47) x = x * 10 + (ch ^ 48);
    x = f ? -x : x;
  }

  io_in& operator>>(int& x) { return read(x), *this; }

  io_in& operator>>(ll& x) { return read(x), *this; }

  io_in& operator>>(uint& x) { return read(x), *this; }

  io_in& operator>>(ull& x) { return read(x), *this; }

  io_in& operator>>(db& x) {
    read(x);
    bool f = x < 0;
    x = f ? -x : x;
    if (ch ^ '.') return *this;

    double d = 0.1;
    while ((ch = getchar()) > 47) x += d * (ch ^ 48), d *= .1;
    return x = f ? -x : x, *this;
  }
} in;

struct io_out {
  char buf[io_size], *s = buf;
  int pw[233], st[233];

  io_out() {
    set(7);
    rep(i, pw[0] = 1, 9) pw[i] = pw[i - 1] * 10;
  }

  ~io_out() { flush(); }

  void io_chk() {
    if (s - buf > io_limit) flush();
  }

  void flush() { fwrite(buf, 1, s - buf, stdout), fflush(stdout), s = buf; }

  io_out& operator<<(char c) { return *s++ = c, *this; }

  io_out& operator<<(string str) {
    for (char c : str) *s++ = c;
    return io_chk(), *this;
  }

  io_out& operator<<(char* str) {
    char* cur = str;
    while (*cur) *s++ = *cur++;
    return io_chk(), *this;
  }

  template <class T>

  void write(T x) {
    if (x < 0) *s++ = '-', x = -x;

    do {
      st[++st[0]] = x % 10, x /= 10;
    } while (x);

    while (st[0]) *s++ = st[st[0]--] ^ 48;
  }

  io_out& operator<<(int x) { return write(x), io_chk(), *this; }

  io_out& operator<<(ll x) { return write(x), io_chk(), *this; }

  io_out& operator<<(uint x) { return write(x), io_chk(), *this; }

  io_out& operator<<(ull x) { return write(x), io_chk(), *this; }

  int len, lft, rig;

  void set(int _length) { len = _length; }

  io_out& operator<<(db x) {
    bool f = x < 0;
    x = f ? -x : x, lft = x, rig = 1. * (x - lft) * pw[len];
    return write(f ? -lft : lft), *s++ = '.', write(rig), io_chk(), *this;
  }
} out;
#define int long long

template <int sz, int mod>

struct math_t {
	math_t() {
    fac.resize(sz + 1), ifac.resize(sz + 1);
    rep(i, fac[0] = 1, sz) fac[i] = fac[i - 1] * i % mod;

    ifac[sz] = inv(fac[sz]);
    Rep(i, sz - 1, 0) ifac[i] = ifac[i + 1] * (i + 1) % mod;
  }

  vector<int> fac, ifac;

  int qpow(int x, int y) {
    int ans = 1;
    for (; y; y >>= 1, x = x * x % mod)
      if (y & 1) ans = ans * x % mod;
    return ans;
  }

  int inv(int x) { return qpow(x, mod - 2); }

  int C(int n, int m) {
    if (n < 0 || m < 0 || n < m) return 0;
    return fac[n] * ifac[m] % mod * ifac[n - m] % mod;
  }
};

int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
int lcm(int x, int y) { return x * y / gcd(x, y); }

// dp_x = min{dp_y + a_x * b_y}
// a_x 处的 min { (b_y)a_x + dp_y }
// merge

const int maxn = 1e5 + 51;
int rt[maxn], ls[maxn << 5], rs[maxn << 5], id[maxn << 5], cnt = 0;
struct Line {
	int k, b; inline int val(int x) { return k * x + b; }
} s[maxn];

void ins(int &p, int l, int r, int num) {
	if(!p) { p = ++cnt; id[p] = num; return; }
	int mid = l + r >> 1, &x = num, &y = id[p];
	int midx = s[x].val(mid), midy = s[y].val(mid);
	if(midx < midy) { x ^= y ^= x ^= y; }
	int lx = s[x].val(l), ly = s[y].val(l);
	int rx = s[x].val(r), ry = s[y].val(r);
	if(lx >= ly && rx >= ry) return;
	if(lx < ly) ins(ls[p], l, mid, num);
	else ins(rs[p], mid + 1, r, num);
}

int merge(int x, int y, int l, int r) {
	if(!x || !y) return x + y;
	ins(x, l, r, id[y]);
	int mid = l + r >> 1;
	ls[x] = merge(ls[x], ls[y], l , mid);
	rs[x] = merge(rs[x], rs[y], mid + 1, r);
	return x;
}

int qry(int p, int l, int r, int pos) {
	if(!p) return 1e18;
	if(l == r) { return s[id[p]].val(pos); }
	int mid = l + r >> 1, ans = s[id[p]].val(pos);
	if(pos <= mid) { cmin(ans, qry(ls[p], l, mid, pos)); }
	else { cmin(ans, qry(rs[p], mid + 1, r, pos)); }
	return ans;
}

int n;
int L = -1e5, R = 1e5;
int dp[maxn], a[maxn], b[maxn];
vector <int> g[maxn];
void dfs(int u, int f) {
	for(int v: g[u])
		if(v ^ f) { dfs(v, u), rt[u] = merge(rt[u], rt[v], L, R); }
	dp[u] = qry(rt[u], L, R, a[u]);
	if(dp[u] == 1e18) dp[u] = 0;
	s[u] = { b[u], dp[u] }, ins(rt[u], L, R, u);
}

signed main() {
  // code begin.
	in >> n;
	rep(i , 1 , n) in >> a[i]; rep(i , 1 , n) in >> b[i];
	rep(i , 2 , n) { int u, v; in >> u >> v, g[u].pb(v), g[v].pb(u); }
	dfs(1, 0);
	rep(i , 1 , n) { out << dp[i] << '\n'; }
  return 0;
  // code end.
}