#include <bits/stdc++.h>
using namespace std;
static const int MAXN = 100000;
int N, Q;
vector<int> g[MAXN+1];
int st[MAXN+1], en[MAXN+1], euler[2*MAXN+5], timer=0, depth[MAXN+1];
int origMask[MAXN+1];
char S[MAXN+1];

// 27 target masks: 0, 1<<0, 1<<1, ..., 1<<25
int K[27];
struct Node {
    int best[27];
    int lazyXor;
    Node() {
        memset(best, -1, sizeof(best));
        lazyXor = 0;
    }
} seg[4*MAXN+5];

void dfs(int u, int p){
    st[u] = timer;
    euler[timer++] = u;
    for(auto v : g[u]) if(v!=p){
        depth[v] = depth[u]+1;
        origMask[v] = origMask[u] ^ (1 << (S[v]-'a'));
        dfs(v,u);
    }
    en[u] = timer-1;
}

void build(int idx, int L, int R){
    if(L == R){
        int u = euler[L];
        for(int i=0;i<27;i++){
            seg[idx].best[i] = (origMask[u] == K[i]) ? depth[u] : -1;
        }
        return;
    }
    int M = (L+R)>>1;
    build(idx<<1, L, M);
    build(idx<<1|1, M+1, R);
    for(int i=0;i<27;i++){
        seg[idx].best[i] = max(seg[idx<<1].best[i], seg[idx<<1|1].best[i]);
    }
}

void applyXor(int idx, int T){
    // permute best[] by K[i] -> K[i]^T
    int tmp[27];
    for(int i=0;i<27;i++){
        int want = K[i] ^ T;
        // find j such that K[j] == want
        int j = __builtin_ctz(want) + 1; // works because want==0 only when i==0
        if(want == 0) j = 0;
        tmp[j] = seg[idx].best[i];
    }
    memcpy(seg[idx].best, tmp, sizeof(tmp));
    seg[idx].lazyXor ^= T;
}

void push(int idx){
    int &lz = seg[idx].lazyXor;
    if(lz){
        applyXor(idx<<1, lz);
        applyXor(idx<<1|1, lz);
        lz = 0;
    }
}

void update(int idx, int L, int R, int ql, int qr, int T){
    if(ql>R || qr<L) return;
    if(ql<=L && R<=qr){
        applyXor(idx, T);
        return;
    }
    push(idx);
    int M=(L+R)>>1;
    update(idx<<1,  L,   M, ql, qr, T);
    update(idx<<1|1,M+1, R, ql, qr, T);
    for(int i=0;i<27;i++){
        seg[idx].best[i] = max(seg[idx<<1].best[i], seg[idx<<1|1].best[i]);
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> N;
    cin >> (S+1);
    for(int i=1,u,v;i<N;i++){
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    // prepare target masks
    K[0] = 0;
    for(int i=0;i<26;i++) K[i+1] = 1<<i;

    // root=1
    origMask[1] = (1 << (S[1]-'a'));
    depth[1]=1;
    dfs(1,0);

    build(1, 0, N-1);

    cin >> Q;
    while(Q--){
        int X; char C;
        cin >> X >> C;
        int oldb = S[X] - 'a';
        int newb = C   - 'a';
        if(oldb != newb){
            int T = (1<<oldb) ^ (1<<newb);
            update(1, 0, N-1, st[X], en[X], T);
            S[X] = C;
        }
        // answer = max over best[0..26]
        int ans = 0;
        for(int i=0;i<27;i++){
            ans = max(ans, seg[1].best[i]);
        }
        cout << ans << "\n";
    }
    return 0;
}