#include <iostream>
#include <cmath>
#include <numeric>
#include <algorithm>
#include <deque>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
#include <map>
#include <stack>
#include <queue>
#include <functional>
#include <climits>
#include <bitset>
#include <random>
#include <tuple>
#include <initializer_list>
#include <fstream>

struct SubTree {
	long long int min_step, back_for_minstep, need_to_push;
	long long int push_back_multiplier, sum_initial, sum_target;
};
int main() {
	int n; std::cin >> n;
	std::vector<std::vector<int>> nodes(n);
	for (auto i = 1; i < n; ++i) {
		int u, v; std::cin >> u >> v;
		nodes[--u].push_back(--v);
		nodes[v].push_back(u);
	}
	std::vector<int> initial_size(n), target_size(n);
	for (auto& a : initial_size) std::cin >> a;
	for (auto& b : target_size) std::cin >> b;
	std::vector<int> depth(n, -1), parent(n, -1), child_count(n, 0); depth[0] = 0;
	std::stack<int> stack; stack.push(0);
	while (!stack.empty()) {
		const auto top = stack.top(); stack.pop();
		for (const auto next : nodes[top]) if (depth[next] == -1) {
			depth[next] = depth[top] + 1;
			parent[next] = top;
			stack.push(next);
			++child_count[top];
		}
	}
	std::vector<SubTree> sub_trees(n);
	for (auto i = 0; i < n; ++i) if (child_count[i] == 0) {
		stack.push(i);
	}
	while (!stack.empty()) {
		const auto top = stack.top(); stack.pop();
		long long int sum_min_step{ 0 }, sum_back{ 0 }, sum_multiplier{ 0 }, max_need{ 0 }, sum_need{ 0 }, sum_initial_size{ initial_size[top] }, sum_target_size{ target_size[top] };
		for (const auto next: nodes[top]) if (depth[next] > depth[top]) {
			sum_min_step += sub_trees[next].min_step;
			sum_back += sub_trees[next].back_for_minstep;
			sum_multiplier += sub_trees[next].push_back_multiplier;
			max_need = std::max(max_need, sub_trees[next].need_to_push);
			sum_need += sub_trees[next].need_to_push;
			sum_initial_size += sub_trees[next].sum_initial;
			sum_target_size += sub_trees[next].sum_target;
		}
		const auto need_to_push{ std::max(max_need, sum_initial_size - sum_target_size) };
		sum_min_step += need_to_push;
		for (const auto next : nodes[top]) if (depth[next] > depth[top]) {
			sum_min_step += (need_to_push - sub_trees[next].need_to_push) * sub_trees[next].push_back_multiplier;
		}
		sub_trees[top] = SubTree{ sum_min_step, need_to_push, std::max(sum_target_size - sum_initial_size + need_to_push, 0LL),
			sum_multiplier + 1, sum_initial_size, sum_target_size };
		if (parent[top] != -1 && --child_count[parent[top]] == 0) {
			stack.push(parent[top]);
		}
	}
	std::cout << sub_trees[0].min_step << '\n';
}
