\(\mathscr{Description}\)
Link.
给定一棵以 \(1\) 为根的树，点 \(u\) 有非负点权 \(a_u\)。
定义 \(u\) 的一次染色的代价为：路径 \(u\rightarrow 1\) 上染有的不为 \(u\) 的颜色种类，并把该路径上的所有结点颜色染为 \(u\)。
定义一棵树的染色代价为：初始时所有结点无色，以任意顺序对结点进行染色操作，使得结点 \(u\) 恰好被操作 \(a_u\) 次，能得到的最大操作代价和。
给出 \(m\) 次操作，每次给定 \(u,k\)，\(k>0\)，令 \(a_u\leftarrow a_u+k\)。每次修改后求出这棵树的染色代价。
\(n,m\le4\times10^5\)。
\(\mathscr{Solution}\)
惯用 trick：染色时的颜色冲突一定可以在 LCA 处不重不漏地统计。对于 \(u\)，设其子树内的 \(a\) 之和为 \(s\)，自己的权值以及孩子子树和的最大值为 \(x\)，显然 \(u\) 处最多冲突
次，而 \(\sum_u f(s_u,x_u)\) 就是答案。
奇妙的观察：修改的 \(k>0\)，因此修改若在 \(u\) 的最大值子树内且 \(2x_u>s_u\)，则一定不会导致 \(f(s_u,x_u)\) 改变。
因此，可以 LCT 动态维护树形，\(u\) 与其原树孩子 \(v\) 是实边当且仅当 \(2s_u>s_v\)。注意这样的规定虽然导致我们完全不能 access，但是每遇到一条虚边，子树和 \(\times 2\)，故任意结点到根的虚边数量恒不超过 \(\mathcal O(\log V)\)。修改时，转一转 splay，讨论一下每条虚边的取舍即可。
虚边访问次数是 \(\mathcal O(q\log V)\)，但 splay 内部是否能套用 LCT 的均摊证明其复杂度呢？或者说有什么巧妙的证明方法呢？求教 qwq。
\(\mathscr{Code}\)
/*+Rainybunny+*/
#include <bits/stdc++.h>
#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)
#ifndef RYBY
# undef assert
# define assert(expr) // do nothing.
#endif
typedef long long LL;
inline char fgc() {
static char buf[1 << 17], *p = buf, *q = buf;
return p == q && (q = buf + fread(p = buf, 1, 1 << 17, stdin), p == q) ?
EOF : *p++;
}
template <typename Tp = int>
inline Tp rint() {
Tp x = 0, s = fgc(), f = 1;
for (; s < '0' || '9' < s; s = fgc()) f = s == '-' ? -f : f;
for (; '0' <= s && s <= '9'; s = fgc()) x = x * 10 + (s ^ '0');
return x * f;
}
template <typename Tp>
inline void wint(Tp x) {
if (x < 0) putchar('-'), x = -x;
if (9 < x) wint(x / 10);
putchar(x % 10 ^ '0');
}
const int MAXN = 4e5;
int n, m, ecnt, head[MAXN + 5];
struct Edge { int to, nxt; } graph[MAXN * 2 + 5];
LL ans;
inline void link(const int u, const int v) {
graph[++ecnt] = { v, head[u] }, head[u] = ecnt;
graph[++ecnt] = { u, head[v] }, head[v] = ecnt;
}
struct LinkCutTree {
int fa[MAXN + 5], ch[MAXN + 5][2];
LL val[MAXN + 5], asum[MAXN + 5], vsum[MAXN + 5];
inline bool nroot(const int u) {
return ch[fa[u]][0] == u || ch[fa[u]][1] == u;
}
inline void pushup(const int u) {
asum[u] = asum[ch[u][0]] + asum[ch[u][1]] + val[u] + vsum[u];
}
inline LL contr(const int u) {
assert(!nroot(u));
LL s = asum[u] - asum[ch[u][0]];
if (ch[u][1]) {
// assert(asum[ch[u][1]] << 1 > s);
return s - asum[ch[u][1]] << 1;
}
if (val[u] << 1 > s) return s - val[u] << 1;
return s - 1;
}
inline void init(const int u) { // specialized.
int mx = u; asum[u] = val[u];
for (int i = head[u], v; i; i = graph[i].nxt) {
if ((v = graph[i].to) != fa[u]) {
fa[v] = u, init(v), vsum[u] += asum[v];
if (asum[v] > asum[mx]) mx = v;
}
}
asum[u] += vsum[u];
if (mx != u && asum[mx] << 1 > asum[u]) {
ch[u][1] = mx, vsum[u] -= asum[mx];
}
ans += contr(u);
}
inline void rotate(const int u) {
int v = fa[u], w = fa[v], k = ch[v][1] == u;
fa[u] = w; if (nroot(v)) ch[w][ch[w][1] == v] = u;
if ((ch[v][k] = ch[u][!k])) fa[ch[v][k]] = v;
pushup(ch[fa[v] = u][!k] = v), pushup(u);
}
inline void splay(const int u) {
for (int v; nroot(u); rotate(u)) {
if (nroot(v = fa[u])) {
rotate(u ^ v ^ ch[v][0] ^ ch[fa[v]][0] ? u : v);
}
}
}
inline void update(const int u, const int k) { // semi-access.
for (int v = u; v; v = fa[v]) {
splay(v), ans -= contr(v);
asum[v] += k, (u == v ? val[v] : vsum[v]) += k;
}
if (asum[ch[u][1]] << 1 <= asum[u] - asum[ch[u][0]]) {
vsum[u] += asum[ch[u][1]], ch[u][1] = 0;
}
ans += contr(u);
for (int v = u, w; (w = fa[v]); v = w) {
LL s = asum[w] - asum[ch[w][0]];
if (asum[ch[w][1]] << 1 <= s) {
vsum[w] += asum[ch[w][1]], ch[w][1] = 0;
}
if (asum[v] << 1 > s) {
vsum[w] -= asum[v], ch[w][1] = v;
}
ans += contr(w);
}
}
} lct;
int main() {
n = rint(), m = rint();
rep (i, 1, n) lct.val[i] = rint();
rep (i, 2, n) link(rint(), rint());
lct.init(1);
wint(ans), putchar('\n');
for (int u, k; m--;) {
u = rint(), k = rint();
lct.update(u, k);
wint(ans), putchar('\n');
}
return 0;
}