[wc2013]糖果公园(70分)

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <algorithm>

#define REP(i, n) for (i = 0; i < (n); ++i)
#define FER(i, j) for (i = lst[j]; i; i = i->n)
#define int64 long long
#ifdef WIN32
#define fmt64 "%I64d"
#else
#define fmt64 "%lld"
#endif
#define oo 0x13131313
#define maxn 90002
#define BLOCK 300

using namespace std; double now;

template<class T> void read(T &x)
{
	char c = getchar();
	for (; '0' > c || c > '9'; c = getchar());
	x = c - '0', c = getchar();
	for (; '0' <= c && c <= '9'; c = getchar())
		x = x * 10 + c - '0';
}

int n, m, Q, w[maxn], c[maxn]; short Mod[maxn]; int64 v[maxn];
int pa[maxn], size[maxn], ufs[maxn], dep[maxn], dfn[maxn], Dfn, ca[maxn];
int F, f, mark[maxn], tot, a[maxn], Mark;
int64 buf[maxn * BLOCK], *buft = buf, *ans[maxn], *Ans;

struct edge { int t; edge *n; } edges[maxn * 2], *adj = edges, *lst[maxn], *fr[maxn];
struct block { int a[BLOCK]; } blocks[maxn + BLOCK], *btot = blocks;
struct array { block *a[BLOCK]; int operator[](int); } sum[maxn];

int array::operator[](int b) { return --b, a[b / BLOCK]->a[Mod[b]]; }

void inherit(array &a, array &b, int pos)
{
	block *&p = a.a[--pos / BLOCK];
	memcpy(&a, &b, sizeof(array)), memcpy(btot, p, sizeof(block));
	p = btot++, ++p->a[Mod[pos]];
}

int find(int x)
{
	int f, g;
	for (f = x; ufs[f] != f; f = ufs[f]);
	for (; ufs[x] != x; x = g) g = ufs[x], ufs[x] = f;
	return f;
}

void dfs(int u, int fa)
{
	edge *e; int f = -1;
	inherit(sum[u], sum[fa], c[u]), dep[u] = dep[fa] + 1, dfn[u] = ++Dfn;
	FER(e, u) if (e->t != fa)
	{
		dfs(e->t, u), fr[e->t] = e, pa[e->t] = u;
		if (!~f || size[f] + size[e->t] > BLOCK << 1)
			f = e->t;
		else
			size[f] += size[e->t], ca[f] = u, ufs[e->t] = f;
	}
	ca[u] = ufs[u] = u, size[u] = 1;
	if (~f && size[f] < BLOCK)
		size[u] += size[f], ufs[f] = u;
}

void bfs(int S)
{
	static int q[maxn]; int h, t; edge *e;
	for (q[h = t = S] = 0; h; h = q[h])
	{
		Ans[h] = Ans[pa[h]] + v[c[h]] * w[sum[F][c[h]] - (sum[f][c[h]] << 1) + sum[h][c[h]] + (c[f] == c[h])];
		FER(e, h) if (e->t != pa[h]) q[t = q[t] = e->t] = 0;
	}
}

void init()/*pretreat for the answers between blocks*/
{
	int i, j; edge *e;
	REP(i, BLOCK) sum->a[i] = btot++;
	dfs(1, 0);
	fprintf(stderr, "%.2lf\n", (clock() - now) / CLOCKS_PER_SEC);
	REP(i, n) if (find(i + 1) == i + 1)
	{
		F = f = ca[i + 1];
		if (ans[f]) continue;
		buft += n, Ans = ans[f] = buft - n - 1;
		Ans[f] = v[c[f]] * w[1];
		FER(e, f) if (e->t != pa[f]) bfs(e->t);
		for (j = f; fr[j]; j = f)
		{
			f = pa[j];
			Ans[f] = Ans[j] + v[c[f]] * w[sum[F][c[f]] - sum[f][c[f]] + 1];
			for (e = fr[j]->n; e; e = e->n)
				if (e->t != pa[f]) bfs(e->t);
		}
	}
}

int64 ask(int x, int y)
{
	int i, j, f; int64 res = 0; ++Mark, tot = 0;
	for (i = x; i; i = pa[i]) mark[i] = Mark;
	for (f = y; mark[f] < Mark; f = pa[f]) a[++tot] = c[f];
	a[++tot] = c[f];
	for (i = x; i != f; i = pa[i]) a[++tot] = c[i];
	sort(a + 1, a + tot + 1);
	for (i = 1; i <= tot; )
		for (j = 0, f = a[i]; a[i] == f && i <= tot; ++i)
			res += v[f] * w[++j];
	return res;
}

void Dfs(int u, int fa)
{
	edge *e; pa[u] = fa;
	for (e = lst[u]; e; e = e->n)
		if (e->t != fa) Dfs(e->t, u);
}

void input()
{
	int i; scanf("%d%d%d", &n, &m, &Q);
	REP(i, m) read(v[i + 1]);
	REP(i, n) read(w[i + 1]), Mod[i] = i % BLOCK;
	REP(i, n - 1)
	{
		int a, b; read(a), read(b);
		*adj = (edge){b, lst[a]}, lst[a] = adj++;
		*adj = (edge){a, lst[b]}, lst[b] = adj++;
	}
	REP(i, n) read(c[i + 1]);
	if (n <= 20000 && m <= 20000)
	{
		for (Dfs(1, 0); Q--; )
		{
			int t, x, y; read(t), read(x), read(y);
			t ? printf(fmt64"\n", ask(x, y)) : c[x] = y;
		}
		exit(0);
	}
}

int LCA(int x, int y)
{
	for (; x != y; )
		ufs[x] == ufs[y] ?
			dep[x] > dep[y] ? x = pa[x] : y = pa[y] :
			dep[ufs[x]] > dep[ufs[y]] ? x = pa[ufs[x]] : y = pa[ufs[y]];
	return x;
}

int main()
{
	freopen("park.in", "r", stdin);
	freopen("park.out", "w", stdout);

	now = clock();
	input();
	init();
	fprintf(stderr, "%.2lf\n", (clock() - now) / CLOCKS_PER_SEC);
	for (; Q--; )
	{
		int t, x, y; read(t), read(x), read(y);
		if (!t) exit(0); if (dfn[y] < dfn[x]) swap(x, y);
		int f = ca[ufs[x]], g = LCA(x, y);
		int64 Ans = ans[f][y];
		if (dep[f] < dep[g])
		{
			for (t = pa[g]; t != pa[f]; t = pa[t])
				Ans -= v[c[t]] * w[sum[y][c[t]] - sum[t][c[t]] + 1];
			f = g;
		}
		for (t = x; t != f; t = pa[t])
			Ans += v[c[t]] * w[sum[y][c[t]] - (sum[g][c[t]] << 1) + sum[t][c[t]] + (c[g] == c[t])];
		printf(fmt64"\n", Ans);
	}
	fprintf(stderr, "%.2lf\n", (clock() - now) / CLOCKS_PER_SEC);
}