#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize ("O3")
//#pragma GCC target ("sse4")

#define endl "\n"

template<class T, class T2> inline bool chkmax(T &x, const T2 &y) { return x < y ? x = y, 1 : 0; }
template<class T, class T2> inline bool chkmin(T &x, const T2 &y) { return x > y ? x = y, 1 : 0; }

#ifndef LOCAL
#define cerr if(false) cerr
#endif
#define out(x) #x << " = " << x << "  "

typedef long long ll;
const int MAXN = 2005;
int N;
char S[MAXN];
vector<int> adj[MAXN];
int up[MAXN][12], depthArr[MAXN];

char pathBuf[MAXN];
int d1[MAXN], d2[MAXN];

void dfs(int u, int p) {
    up[u][0] = p;
    for (int k = 1; k < 12; k++) {
        up[u][k] = up[ up[u][k-1] ][k-1];
    }
    for (int v: adj[u]) if (v != p) {
        depthArr[v] = depthArr[u] + 1;
        dfs(v, u);
    }
}

int lca(int u, int v) {
    if (depthArr[u] < depthArr[v]) swap(u, v);
    int diff = depthArr[u] - depthArr[v];
    for (int k = 0; k < 12; k++) {
        if (diff & (1<<k)) u = up[u][k];
    }
    if (u == v) return u;
    for (int k = 11; k >= 0; k--) {
        if (up[u][k] != up[v][k]) {
            u = up[u][k];
            v = up[v][k];
        }
    }
    return up[u][0];
}

int buildPath(int u, int v) {
    int w = lca(u, v);
    int len = 0;
    int x = u;
    while (x != w) {
        pathBuf[len++] = S[x];
        x = up[x][0];
    }
    pathBuf[len++] = S[w];
    int revStart = len;
    x = v;
    while (x != w) {
        pathBuf[len++] = S[x];
        x = up[x][0];
    }
    for (int i = revStart, j = len-1; i < j; i++, j--) {
        swap(pathBuf[i], pathBuf[j]);
    }
    return len;
}

ll countPals(const char *t, int L) {
    ll cnt = 0;
    int l = 0, r = -1;
    for (int i = 0; i < L; i++) {
        int k = (i > r ? 1 : min(d1[l + r - i], r - i + 1));
        while (i - k >= 0 && i + k < L && t[i-k] == t[i+k]) k++;
        d1[i] = k--;
        cnt += d1[i];
        if (i + k > r) {
            l = i - k;
            r = i + k;
        }
    }
    l = 0; r = -1;
    for (int i = 0; i < L; i++) {
        int k = (i > r ? 0 : min(d2[l + r - i + 1], r - i + 1));
        while (i - k - 1 >= 0 && i + k < L && t[i-k-1] == t[i+k]) k++;
        d2[i] = k--;
        cnt += d2[i];
        if (i + k > r) {
            l = i - k - 1;
            r = i + k;
        }
    }
    return cnt;
}

void solve() {
    cin >> N;
    for (int i = 1; i <= N; i++) {
        cin >> S[i];
        adj[i].clear();
    }
    for (int i = 0; i < N-1; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    depthArr[1] = 0;
    dfs(1, 1);

    int Q;
    cin >> Q;
    while (Q--) {
        int u, v;
        cin >> u >> v;
        int len = buildPath(u, v);
        ll ans = countPals(pathBuf, len);
        cout << ans << endl;
    }
}

signed main() {
#ifndef LOCAL
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    freopen("ferrari.in", "r", stdin);
    freopen("ferrari.out", "w", stdout);
#endif

    solve();
    return 0;
}