CSP-S 游寄

\(\text{reflection}\)

初赛。

本来以为上午要愉快地周测，但是伟大的虎哥让我们在四楼接着练习

然后就目睹了一个万能头+return 0编译 1min30sec 的奇迹 Win7

打了第二类斯特林数 列

未果，寻病终。

下午开始考试

然后 锅锅f 又锅了

很奇妙地等了 20min 才能登陆

然后一个半小时写完了

就在那摆

改错了好几道题

然后考完了

想看一眼沈队 也没看到

但是后来就经常看到了

82.5pts.

复赛。

考前七天在宾馆隔离。

模拟赛成绩一次比一次差，到最后似乎是放弃了场上打正解的尝试

于是CSP时盯着傻瓜题的部分分就是拿

出场后发现除了我都切了

考试策略大概是每道题给一个小时，如果没有思路就赶紧打暴力滚蛋

然后四道题四个暴力

不知道能不能上 200pts

T1 感觉可以直接 sort 后取后 20 个 但是连大样例都过不去 40pts

T2 冲了 n + 4 个 st表后拿了 85pts，以为自己肯定想不出来这种nb题了就跳了

出场发现 T2 签到 wssb

T3 想到内向基环树森林后打了单次 \(O(n)\) 的sb拓扑排序 40pts

明明拿个set乱搞就能 60pts

正解思路不会 sum hash 从没见过

T4 打了暴力和 k = 1 的部分分 以为能有四十多分

但是出场一测代码发现nmd前向星没开双倍边

然后2e5的k=1都寄了 以后用vector（

最后看infoj的自测挂成了205pts

这次总体来说很寄，我是寄寄大王

希望 noip rp++

对了ioj自测里rk1是apj

赛后当天晚上在洗澡

10min 拿到了 350pts

行吧

update : 40+85+65+36=226

不愧是 ccf

白鸟过河滩好听的

link

\(\text{Solution}\)

好像这题解有点意识流？

T1 假期计划

小熊的地图上有 \(n\) 个点，其中编号为 \(1\) 的是它的家、编号为 \(2, 3, \ldots, n\) 的都是景点。部分点对之间有双向直达的公交线路。如果点 \(x\) 与 \(z_1\)、\(z_1\) 与 \(z_2\)、……、\(z_{k - 1}\) 与 \(z_k\)、\(z_k\) 与 \(y\) 之间均有直达的线路，那么我们称 \(x\) 与 \(y\) 之间的行程可转车 \(k\) 次通达；特别地，如果点 \(x\) 与 \(y\) 之间有直达的线路，则称可转车 \(0\) 次通达。

很快就要放假了，小熊计划从家出发去 \(4\) 个不同的景点游玩，完成 \(5\) 段行程后回家：家 \(\to\) 景点 A \(\to\) 景点 B \(\to\) 景点 C \(\to\) 景点 D \(\to\) 家且每段行程最多转车 \(k\) 次。转车时经过的点没有任何限制，既可以是家、也可以是景点，还可以重复经过相同的点。例如，在景点 A \(\to\) 景点 B 的这段行程中，转车时经过的点可以是家、也可以是景点 C，还可以是景点 D \(\to\) 家这段行程转车时经过的点。

假设每个景点都有一个分数，请帮小熊规划一个行程，使得小熊访问的四个不同景点的分数之和最大。

\(5 \le n \le 2500\)，\(1 \le m \le 10000\)，\(0 \le k \le 100\)。

由于是 \(1\to a\to b\to c\to d\to 1\) 的无向图上环，考虑拆成 \(1\to a\to b + 1\to d\to c\) 的两条线路后拼合。

考虑枚举 \(b,c\)，选择最优的 \(a,d\) 作为答案。由于 \(a \neq c, a\neq d\)，需要对每个 \(b\) 维护前三大的答案。

首先在 \(O(nm)\) 的复杂度内处理任意两点间连通性，bfs 即可。

随后考虑 \(1\to a\to b\) 的路径。

枚举 \(b\)，枚举每个点 \(a\)。若这两点可以拼合成路径，则将 \(a\) 插入 \(b\) 的答案集合中。

这部分的复杂度 \(O(n^2)\)。

然后考虑枚举 \(b,c\)，使用两个点的答案集合拼出答案。这时只需要保证四个点彼此不同，\(b\to c\) 可行即可。

这部分的复杂度 \(O(n^2)\)，带 \(9\) 的常数。

于是我们在 \(O(nm + n^2)\) 的复杂度内得到答案。

当然你也可以记录 \(i\) 节点在拓展 \(1/2/3/4\) 次后前几长的路径，最后直接得到答案。时间复杂度相同。

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
template<typename T> void get(T & x) {
	x = 0; char ch = getchar(); bool f = false;
	while (ch < '0' or ch > '9') f = f or ch == '-', ch = getchar();
	while ('0' <= ch and ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); f && (x = -x);
} template <typename T, typename ... Args> void get(T & a, Args & ... b) { get(a); get(b...); }
#define rep(i,s,t) for (register int i = s, i##_ = t + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = s, i##_ = t - 1; i > i##_; -- i)
const int N = 2500 + 10;
int n, m, k, a[N], t1, t2, gp[N][N], ans;
vector <int> g[N];

bool diff(const vector<int> a) {
    rep(i,0,a.size()-1) rep(j,i+1,a.size()-1) if (a[i] == a[j]) return false;
    return true;
} 

struct info {
    int self, pos[4], cnt;

    void insert(int p) {
        if (p == self) return;
        if (cnt < 3) pos[++cnt] = p, sort(pos+1, pos+1+cnt, [&](int x, int y){ return a[x] > a[y]; });
        else if (a[pos[3]] < a[p]) pos[3] = p, sort(pos+1, pos+1+cnt, [&](int x, int y){ return a[x] > a[y]; });
    }

    int operator + (const info & b) const {
        int ret = 0;
        rep(i,1,cnt) rep(j,1,b.cnt) {
            if (gp[self][b.self] and diff( {self, b.self, pos[i], b.pos[j]} )) {
                ret = max(ret, a[self] + a[b.self] + a[pos[i]] + a[b.pos[j]]);
            }
        }
        return ret;
    }
} f[N];

int dis[N];
queue <int> que;
void bfs(int st) {
    rep(i,1,n) gp[st][i] = false, dis[i] = 1e9;
    gp[st][st] = true; dis[st] = 0; que.push(st);
    while (que.size()) {
        int u = que.front(); que.pop();
        if (dis[u] > k) continue;
        for (int v : g[u]) if (dis[v] == 1e9) {
            dis[v] = dis[u] + 1; gp[st][v] = 1;
            que.push(v);
        }
    }
}

signed main() {
	get(n, m, k);
    rep(i,2,n) get(a[i]);
    rep(i,1,m) get(t1, t2), g[t1].push_back(t2), g[t2].push_back(t1);
    rep(i,1,n) bfs(i), f[i].self = i;
    rep(i,2,n) rep(j,2,n) if (i != j and gp[1][i] and gp[i][j]) f[j].insert(i);
	rep(i,2,n) rep(j,2,n) if (i != j) ans = max(ans, f[i] + f[j]);
    cout << ans << endl;
	return 0;
}

T2 策略游戏

有一个长度为 \(n\) 的数组 \(A\) 和一个长度为 \(m\) 的数组 \(B\)，在此基础上定义一个大小为 \(n \times m\) 的矩阵 \(C\)，满足 \(C_{i j} = A_i \times B_j\)。所有下标均从 \(1\) 开始。

游戏一共会进行 \(q\) 轮，在每一轮游戏中，会事先给出 \(4\) 个参数 \(l_1, r_1, l_2, r_2\)，满足 \(1 \le l_1 \le r_1 \le n\)、\(1 \le l_2 \le r_2 \le m\)。

游戏中，小 L 先选择一个 \(l_1 \sim r_1\) 之间的下标 \(x\)，然后小 Q 选择一个 \(l_2 \sim r_2\) 之间的下标 \(y\)。定义这一轮游戏中二人的得分是 \(C_{x y}\)。

小 L 的目标是使得这个得分尽可能大，小 Q 的目标是使得这个得分尽可能小。同时两人都是足够聪明的玩家，每次都会采用最优的策略。

请问：按照二人的最优策略，每轮游戏的得分分别是多少？

\(1 \le n, m, q \le {10}^5\)，\(-{10}^9 \le A_i, B_i \le {10}^9\)。

以为很nb 实际上是傻瓜题

我们开st表维护一个区间负数最值/区间正数最值

分类讨论模拟即可。

为什么 st表 比 线段树 慢一倍以上啊 明明query时少了个 log

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
template<typename T> void get(T & x) {
	x = 0; char ch = getchar(); bool f = false;
	while (ch < '0' or ch > '9') f = f or ch == '-', ch = getchar();
	while ('0' <= ch and ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); f && (x = -x);
} template <typename T, typename ... Args> void get(T & a, Args & ... b) { get(a); get(b...); }
#define rep(i,s,t) for (register int i = s, i##_ = t + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = s, i##_ = t - 1; i > i##_; -- i)
const int N = 1e5 + 10;
const int mx = 1e18;
int n, m, q, a[2][N], l1, r1, l2, r2;

int st[2][4][N][20]; // 0 : 正最大 1 : 负最大 2 : 正最小 3 : 负最小
int lgv[N];

void init(const int & id, const int & n) {
    rep(i,1,n) {
        st[id][0][i][0] = (a[id][i] >= 0 ? a[id][i] : mx);
        st[id][1][i][0] = (a[id][i] <= 0 ? a[id][i] : mx);
        st[id][2][i][0] = (a[id][i] >= 0 ? a[id][i] : mx);
        st[id][3][i][0] = (a[id][i] <= 0 ? a[id][i] : mx);
    }
    rep(j,1,lgv[n]) for (int i = 1; i + (1 << j) - 1 <= n; ++ i) {
        rep(typ,0,1) {
            int x = st[id][typ][i][j-1], y = st[id][typ][i + (1 << j-1)][j - 1];
            if (x != mx and y != mx) st[id][typ][i][j] = max(x, y);
            else st[id][typ][i][j] = (x == mx ? y : x);
        } rep(typ,2,3) {
            int x = st[id][typ][i][j-1], y = st[id][typ][i + (1 << j-1)][j - 1];
            if (x != mx and y != mx) st[id][typ][i][j] = min(x, y);
            else st[id][typ][i][j] = (x == mx ? y : x);
        }
    }
}

int qry(int id, int typ, int l, int r) {
    int d = lgv[r - l + 1];
    if (typ < 2) {
        int x = st[id][typ][l][d], y = st[id][typ][r - (1 << d) + 1][d];
        if (x != mx and y != mx) return max(x, y);
        else return x == mx ? y : x;
    } else {
        int x = st[id][typ][l][d], y = st[id][typ][r - (1 << d) + 1][d];
        if (x != mx and y != mx) return min(x, y);
        else return x == mx ? y : x;
    }
}

struct ans {
    int max1, max2, min1, min2;
};

signed main() {
    ios::sync_with_stdio(false); cin.tie(0), cout.tie(0);
    get(n, m, q);
	rep(i,1,n) get(a[0][i]); rep(i,1,m) get(a[1][i]);
    rep(i,2,max(n, m)) lgv[i] = lgv[i >> 1] + 1;
    init(0, n); init(1, m);
    rep(i,1,q) {
        get(l1, r1, l2, r2);
        ans x = { qry(0, 0, l1, r1), qry(0, 1, l1, r1), qry(0, 2, l1, r1), qry(0, 3, l1, r1) },
            y = { qry(1, 0, l2, r2), qry(1, 1, l2, r2), qry(1, 2, l2, r2), qry(1, 3, l2, r2) };
		if(y.max2 == mx){
			if(x.max1 != mx) cout << 1ll * x.max1 * y.min1 << '\n';
			else cout << x.max2 * y.max1 << '\n';
		}
		else if(y.max1 == mx){
			if(x.max2 != mx) cout << x.min2 * y.max2 << '\n';
			else cout << x.min1 * y.min2 << '\n';
		}
		else {
			int res = -mx;
			if(x.max1 != mx) res = max(res, x.min1 * y.min2);
			if(x.max2 != mx) res = max(res, x.max2 * y.max1);
			cout << res << '\n';
		}
    }
	return 0;
}

T3 星战

给定一张 \(n\) 个点 \(m\) 条边的有向图。一条边 \(u\to v\) 属于 \(v\)。

四种操作：

1. 摧毁一条边，保证边存在且未被摧毁。
2. 重建一条边，保证边存在且已被摧毁。
3. 摧毁属于指定点的所有未被摧毁的边。
4. 重建属于指定点的所有已被摧毁的边。

每次操作后询问当前未被摧毁的边能否形成内向基环树森林。

\(1 \le n,m,q \le 5 \times {10}^5\)。

原题面真nm长

考虑为 YES 当且仅当每个点的出度为 \(1\)。这启发我们记录当前所有边的始点的信息。

考虑一个 sum hash，我们为每个点随机一个大权值，为 YES 只需所有边始点权值加和等于所有点权加和。

然而 2. 4. 操作仍然没法处理。发现 2. 4. 操作是批量改，而考虑 1. 3. 操作更改的边只有 \(O(q)\) 条，如果我们只修改被 1. 3. 操作更改的边就能做到 \(O(q\ f(q))\) 的复杂度。

对每个点开一个 set，其中存的值有两种可能：所有属于该点且被摧毁的边或属于该点且未被摧毁的边。

然后每次 2. 4. 操作暴力修改的复杂度就对了。

复杂度 \(O(q\log q)\)。

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
template<typename T> void get(T & x) {
	x = 0; char ch = getchar(); bool f = false;
	while (ch < '0' or ch > '9') f = f or ch == '-', ch = getchar();
	while ('0' <= ch and ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); f && (x = -x);
} template <typename T, typename ... Args> void get(T & a, Args & ... b) { get(a); get(b...); }
#define rep(i,s,t) for (register int i = s, i##_ = t + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = s, i##_ = t - 1; i > i##_; -- i)
const int N = 5e5 + 10, mod = 1e9 + 9e1;
int n, m, q, typ, u, v, t1, t2, w1[N], w2[N], w1sum[N], w2sum[N], stat[N], sum1, sum2, hsh1, hsh2;
// stat[i] := i 对应 set 里保存的信息 为 1 则保存被删除的边的始点，为 0 则保存仍存在的边的始点 

set<int> st[N];
mt19937 rnd(random_device{}());

int add(int a, int b) { return (a + b) % mod; }

signed main() {
    ios::sync_with_stdio(false); cin.tie(0), cout.tie(0);
    get(n, m);
    rep(i,1,n) {
        w1[i] = rnd() % 100000000, sum1 = add(sum1, w1[i]);
        w2[i] = rnd() % 100000000, sum2 = add(sum2, w2[i]);
        stat[i] = 1;
    }

    rep(i,1,m) {
        get(u, v);
        w1sum[v] = add(w1sum[v], w1[u]);
        w2sum[v] = add(w2sum[v], w2[u]);
        hsh1 = add(hsh1, w1[u]);
        hsh2 = add(hsh2, w2[u]);
    }

    get(q);
    while ( q-- ) {
        get(typ);
        if (typ == 1) {
            get(u, v);
            hsh1 = add(hsh1, mod - w1[u]), hsh2 = add(hsh2, mod - w2[u]);
            if (stat[v]) st[v].insert(u);
            else st[v].erase(u);
        } else if (typ == 2) {
            get(u); t1 = t2 = 0;
            for (int x : st[u]) {
                t1 = add(t1, w1[x]);
                t2 = add(t2, w2[x]);
            }
            if (stat[u] == 0) hsh1 = add(hsh1, - t1 + mod), hsh2 = add(hsh2, - t2 + mod);
            else hsh1 = add(hsh1, t1 - w1sum[u] + mod), hsh2 = add(hsh2, t2 - w2sum[u] + mod) % mod;
            st[u].clear();
            stat[u] = 0;
        } else if (typ == 3) {
            get(u, v);
            hsh1 = add(hsh1, w1[u]), hsh2 = add(hsh2, w2[u]);
            if (stat[v] == 0) st[v].insert(u);
            else st[v].erase(u);
        } else {
            get(u); t1 = t2 = 0;
            for (int x : st[u]) {
                t1 = add(t1, w1[x]);
                t2 = add(t2, w2[x]);
            }
            if (stat[u]) hsh1 = add(hsh1, t1), hsh2 = add(hsh2, t2);
            else hsh1 = add(hsh1, w1sum[u] - t1 + mod), hsh2 = add(hsh2, w2sum[u] - t2 + mod) % mod;
            st[u].clear();
            stat[u] = 1;
        }
        puts((hsh1 == sum1 and hsh2 == sum2) ? "YES" : "NO");
    }
	return 0;
}

T4 数据传输

小 C 正在设计计算机网络中的路由系统。

测试用的网络总共有 \(n\) 台主机，依次编号为 \(1 \sim n\)。这 \(n\) 台主机之间由 \(n - 1\) 根网线连接，第 \(i\) 条网线连接个主机 \(a_i\) 和 \(b_i\)。保证任意两台主机可以通过有限根网线直接或者间接地相连。受制于信息发送的功率，主机 \(a\) 能够直接将信息传输给主机 \(b\) 当且仅当两个主机在可以通过不超过 \(k\) 根网线直接或者间接的相连。

在计算机网络中，数据的传输往往需要通过若干次转发。假定小 C 需要将数据从主机 \(a\) 传输到主机 \(b\)（\(a \neq b\)），则其会选择出若干台用于传输的主机 \(c_1 = a, c_2, \ldots, c_{m - 1}, c_m = b\)，并按照如下规则转发：对于所有的 \(1 \le i < m\)，主机 \(c_i\) 将信息直接发送给 \(c_{i + 1}\)。

每台主机处理信息都需要一定的时间，第 \(i\) 台主机处理信息需要 \(v_i\) 单位的时间。数据在网络中的传输非常迅速，因此传输的时间可以忽略不计。据此，上述传输过程花费的时间为 \(\sum_{i = 1}^{m} v_{c_i}\)。

现在总共有 \(q\) 次数据发送请求，第 \(i\) 次请求会从主机 \(s_i\) 发送数据到主机 \(t_i\)。小 C 想要知道，对于每一次请求至少需要花费多少单位时间才能完成传输。

\(1 \le n, q \le 2 \times {10}^5\)，\(1 \le k \le 3\)，\(1 \le a_i, b_i \le n\)，\(1 \le s_i, t_i \le n\)，\(s_i \ne t_i\)。

场上看到 \(1\le k \le 3\) 感觉是个 sb 数据点分治题

最后发现不是

但是部分分肯定得分治（

k=1 打个树上前缀和就行，k=2 我们发现跳出原链肯定不优因此剖后矩阵乘维护 dp 数组即可。

然后是 k=3.

我们发现 k=3 的转移点都在某个点周围长为 1 的范围内，因此考虑对每个点扫一遍找到它的转移点即可类似 k=2 的情况转移了。

然后剖。剖完维护一个向上的矩乘和向下的矩乘，顺着链扫出需要的矩阵，再把第二段 reverse 一下就能得到需要的 \(O(\log n)\) 个矩阵。顺着乘起来就行了。

时间复杂度 \(O(n \log^2 n)\)，带个 \(9\) 的常数。

当然可以维护每条链从链顶到任意链上位置的矩阵，然后复杂度剪掉一个 \(\log\)。但是常数大得多，时空复杂度都不如两个 \(\log\) 的做法。可能是我写挂了？

这里放两个 \(\log\) 的做法。

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
template<typename T> void get(T & x) {
	x = 0; char ch = getchar(); bool f = false;
	while (ch < '0' or ch > '9') f = f or ch == '-', ch = getchar();
	while ('0' <= ch and ch <= '9') x = (x << 1) + (x << 3) + ch - '0', ch = getchar(); f && (x = -x);
} template <typename T, typename ... Args> void get(T & a, Args & ... b) { get(a); get(b...); }
#define rep(i,s,t) for (register int i = s, i##_ = t + 1; i < i##_; ++ i)
#define pre(i,s,t) for (register int i = s, i##_ = t - 1; i > i##_; -- i)
const int N = 2e5 + 10;
int n, q, k, t1, t2, valk[N];
int dep[N], fa[N], siz[N], son[N], dfn[N], idfn[N], stp, top[N];
vector <int> g[N];

struct mat {
    int a[3][3], n, m;

    mat(int _n, int _m) : n(_n), m(_m) { memset(a, 0x3f, sizeof a); }
    mat(int _n = 0) : n(_n), m(_n) { memset(a, 0x3f, sizeof a); rep(i,0,n-1) a[i][i] = 0; }
    int* operator[] (const int & p) { return a[p]; }
    const int* operator[] (const int & p) const { return a[p]; }

    mat operator* (const mat & b) const {
        mat ret(n, b.m);
        rep(i,0,n-1) rep(j,0,b.m-1) rep(k,0,m-1) {
            ret[i][j] = min(ret[i][j], a[i][k] + b[k][j]);
        } return ret;
    }
};

struct SegmentBeats {
    mat seg[N << 2];
    #define ls (p << 1)
    #define rs (p << 1 | 1)

    void upd(int p, int l, int r, int pos, mat val) {
        if (l == r) { seg[p] = val; return; }
        int mid = l + r >> 1;
        if (pos <= mid) upd(ls, l, mid, pos, val);
        else upd(rs, mid+1, r, pos, val);
        seg[p] = seg[ls] * seg[rs];
    }

    mat qry(int p, int l, int r, int L, int R) {
        if (L > R) return mat(k);
        if (L <= l and r <= R) return seg[p];
        int mid = l + r >> 1;
        if (R <= mid) return qry(ls, l, mid, L, R);
        else if (mid < L) return qry(rs, mid+1, r, L, R);
        else return qry(ls, l, mid, L, R) * qry(rs, mid+1, r, L, R);
    }

    #undef ls
    #undef rs
} tr1, tr2;

void find_hc(int u, int f) {
    dep[u] = dep[f] + 1, fa[u] = f; siz[u] = 1;
    for (int v : g[u]) if (v != f) {
        find_hc(v, u);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]]) son[u] = v;
    }
}

void con_hc(int u, int ctop) {
    dfn[u] = ++stp, idfn[stp] = u; top[u] = ctop;
    if (son[u]) con_hc(son[u], ctop);
    for (int v : g[u]) if (v != fa[u] and v != son[u]) {
        con_hc(v, v);
    }
}

int find(int u) {
    int ans = 2e9;
    for (int v : g[u]) ans = min(ans, valk[v]);
    return ans;
}

mat getv(int u) {
    mat ret(k, k);
    rep(i,0,k-1) ret[i][0] = valk[u];
    rep(i,1,k-1) ret[i-1][i] = 0;
    if (k == 3) ret[1][1] = find(u);
    return ret;
}

void upd(int pos, mat val) {
    tr1.upd(1, 1, n, dfn[pos], val);
    tr2.upd(1, 1, n, n - dfn[pos] + 1, val);
}

int query(int s, int t) {
    int S = s;
    static vector<mat> a, b; a.clear(), b.clear();
    bool ck = true;
    while (top[s] != top[t]) {
        if (dep[top[s]] > dep[top[t]]) {
            if (ck) a.push_back(tr2.qry(1, 1, n, n - dfn[s] + 2, n - dfn[top[s]] + 1)), ck = false;
            else    a.push_back(tr2.qry(1, 1, n, n - dfn[s] + 1, n - dfn[top[s]] + 1));
            s = fa[top[s]];
        } else {
            b.push_back(tr1.qry(1, 1, n, dfn[top[t]], dfn[t]));
            t = fa[top[t]];
        }
    } if (dfn[s] >= dfn[t]) {
        if (ck) a.push_back(tr2.qry(1, 1, n, n - dfn[s] + 2, n - dfn[t] + 1)), ck = false;
        else    a.push_back(tr2.qry(1, 1, n, n - dfn[s] + 1, n - dfn[t] + 1));
    } else {
        if (ck) b.push_back(tr1.qry(1, 1, n, dfn[s] + 1, dfn[t])), ck = false;
        else    b.push_back(tr1.qry(1, 1, n, dfn[s], dfn[t]));
    }
    reverse(b.begin(), b.end());
    mat w(1, k);
    w[0][0] = valk[S];
    for (mat tmp : a) w = w * tmp;
    for (mat tmp : b) w = w * tmp;
    return w[0][0];
}

signed main() {
    get(n, q, k);
    rep(i,1,n) get(valk[i]);
    rep(i,2,n) get(t1, t2), g[t1].push_back(t2), g[t2].push_back(t1);
    find_hc(1, 0); con_hc(1, 1);
    rep(i,1,n) upd(i, getv(i));
    while ( q-- ) {
        get(t1, t2);
        cout << query(t1, t2) << '\n';
    }

	return 0;
}