CF1394D

所谓单调递增或单调递减，其实只用看成一条有向的链，$b$ 大的点指向 $b$ 小的点即可。

所以对于边 $(u,v)$，假设 $b_u\ne b_v$，那么这条边的方向确定。

一个点对答案的贡献是经过它的链数，设 $x$ 为指向它的边的数量，$y$ 为它指出去的边的数量，那么贡献就是 $a_i\times \max(x,y)$。

问题等价于你需要给两端高度相等的边确定方向最小化贡献和。

设 $f_{u,0/1}$ 表示以 $u$ 为根的子树，$u$ 到父亲的边强制为连入 / 连出情况下的最小贡献和。

更具体的，问题变成给定 $m$ 个二元组 $(f_{v,0},f_{v,1})$ 给每个二元组选择一个权值，然后设 $x,y$ 分别为 $0/1$ 的数量，贡献和加上 $a_u\times\max(x,y)$。

可以先假设不确定的所有元素选 $0$，然后依次枚举 $1$ 的数量，不难发现我们肯定优先选 $f_{v,1}-f_{v,0}$ 尽可能小的元素。

然后即时更新一下贡献，特判一下根节点，这个题就做完了。

时间复杂度 $\mathcal O(n\log n)$。

Code：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005;
int n;
int a[N], b[N];
ll f[N][2];
int head[N], ver[N*2], nxt[N*2], cnt;
vector <ll> tmp[N];

void add(int u, int v) {
	ver[++cnt] = v, nxt[cnt] = head[u], head[u] = cnt;
}

void chkmin(ll &a, ll b) { if (a > b) a = b; }

void dfs(int u, int fa) {
	ll sum = 0, cnt1 = 0, cnt2 = 0;
	for (int i = head[u]; i; i = nxt[i]) {
		int v = ver[i];
		if (v == fa) continue;
		dfs(v, u);
		if (b[v] == b[u]) tmp[u].push_back(f[v][1] - f[v][0]), sum += f[v][0], ++cnt1;
		else if (b[v] > b[u]) sum += f[v][1], ++cnt2;
		else sum += f[v][0], ++cnt1;
	}
	sort(tmp[u].begin(), tmp[u].end());
	for (int i = 0; i <= tmp[u].size(); ++i) {
		chkmin(f[u][0], sum + max(cnt1, cnt2 + (u != 1)) * a[u]);
		chkmin(f[u][1], sum + max(cnt1 + (u != 1), cnt2) * a[u]);
		--cnt1, ++cnt2;
		if (i < tmp[u].size()) sum += tmp[u][i];
	}
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
	for (int i = 1; i <= n; ++i) scanf("%d", &b[i]);
	for (int i = 1, u, v; i < n; ++i) scanf("%d%d", &u, &v), add(u, v), add(v, u);
	memset(f, 0x3f, sizeof f);
	dfs(1, 0);
	printf("%lld", min(f[1][0], f[1][1]));
	return 0;
}