#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")

using namespace std;

const int N = 2e5 + 5, LIM = 1e6, P = 998244353, G = 3, iG = (P + 1) / G;

string s;
int f[3][N], inv[LIM + 5];

int ksm(int x, int y = P - 2) {
    if (x <= LIM && y == P - 2) {
        return inv[x];
    }
    int res = 1;
    while (y) {
        if (y & 1) {
            res = 1ll * res * x % P;
        }
        x = 1ll * x * x % P;
        y >>= 1;
    }
    return res;
}

string Init() {
    inv[1] = 1;
    for (int i = 2; i <= LIM; ++i) {
        inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
    }
    return "Success";
}

string status = Init();

typedef vector<int> poly;

void simpl(poly &x) {
    while (!x.empty() && !x.back()) {
        x.pop_back();
    }
    return;
}

poly NTT(poly f, int type = 0) {
    int n = f.size();
    assert(n && !(n & (n - 1)));
    poly tr(n);
    for (int i = 1; i < n; ++i) {
        tr[i] = (tr[i >> 1] >> 1) | ((i & 1) ? n >> 1 : 0);
        if (i < tr[i]) {
            swap(f[i], f[tr[i]]);
        }
    }
    for (int len = 2; len <= n; len <<= 1) {
        int p = len >> 1, buf = ksm((type ? iG : G), (P - 1) / len);
        for (int i = 0; i < n; i += len) {
            int now = 1;
            for (int j = i; j < i + p; ++j) {
                int tmp = 1ll * now * f[j + p] % P;
                ((f[j + p] = f[j] - tmp) < 0) && (f[j + p] += P);
                ((f[j] += tmp) >= P) && (f[j] -= P);
                now = 1ll * now * buf % P;
            }
        }
    }
    if (type) {
        int invN = ksm(n);
        for (auto &v : f) {
            v = 1ll * v * invN % P;
        }
    }
    return f;
}

poly operator * (poly x, poly y) {
    if (x.empty() || y.empty()) {
        return {};
    }
    simpl(x), simpl(y);
    int len = x.size() + y.size() - 1, tLen = 1;
    while (tLen < len) {
        tLen <<= 1;
    }
    x.resize(tLen), y.resize(tLen);
    x = NTT(x), y = NTT(y);
    for (int i = 0; i < tLen; ++i) {
        x[i] = 1ll * x[i] * y[i] % P;
    }
    x = NTT(x, 1);
    simpl(x);
    return x;
}

poly mul(vector<poly> x) {
    if (x.size() == 1) return x[0];
    int mid = x.size() >> 1;
    vector<poly> l, r;
    for (int i = 0; i < x.size(); ++i) {
        if (i < mid) l.push_back(x[i]);
        else r.push_back(x[i]);
    }
    return mul(l) * mul(r);
}

vector< pair<int, int> > Gv[N];

void dfs(int x, int fa = -1, int c = 1) {
    vector<poly> tres;
    int ct = 1;
    if (s[x] == 'S') tres.push_back((poly){1, 1, 0});
    else tres.push_back((poly){0, 1, 1});
    for (auto [v, w] : Gv[x]) if (v != fa) {
        ++ct;
        dfs(v, x, w);
        if (w == 2) {
            tres.push_back((poly){0, f[1][v], f[2][v]});
        } else {
            tres.push_back((poly){f[0][v], f[1][v], 0});
        }
    }
    poly res = mul(tres);
    for (int i = 0; i <= 2; ++i) if (i == 1 || i == c) {
        f[i][x] = ct + i - 1 >= 0 && ct + i - 1 < res.size() ? res[ct + i - 1] : 0;
    }
}

signed main() {
    int n; scanf("%d", &n); cin >> s; s = ' ' + s;
    for (int i = 1; i < n; ++i) {
        int x, y; scanf("%d%d", &x, &y);
        Gv[x].push_back(make_pair(y, 2));
        Gv[y].push_back(make_pair(x, 0));
    }
    dfs(1);
    printf("%d\n", (f[1][1] % P + P) % P);
    return 0;
}