#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
using LL = long long;
const int maxn = 2e6 + 5, mod = 998244353, G = 3, Gi = 332748118;

int qpow(int a, int b, int mod){
    int res = 1;
    while (b){
        if (b & 1) res = 1LL * res * a % mod;
        a = 1LL * a * a % mod;
        b >>= 1;
    }
    return res;
}

inline int mul(int a, int b){
    return 1LL * a * b % mod;
}

inline void add(int &a, int b){
    a += b;
    if (a >= mod) a -= mod;
}

inline void sub(int &a, int b){
    a -= b;
    if (a < 0) a += mod;
}

int inv[(1 << 21) + 5], fact[(1 << 21) + 5], invfact[(1 << 21) + 5];
void init(int n){
    inv[1] = 1;
    for(int i = 2; i <= n; i++)
        inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod; 
    fact[0] = invfact[0] = 1;
    for(int i = 1; i <= n; i++)
        fact[i] = mul(fact[i - 1], i);
    invfact[n] = qpow(fact[n], mod - 2, mod);
    for(int i = n - 1; i >= 1; i--)
        invfact[i] = mul(invfact[i + 1], i + 1);  
}

int C(int a, int b){
    if (a < 0 || b < 0 || a < b) return 0;
    return mul(mul(fact[a], invfact[b]), invfact[a - b]);
}

namespace NTT{
    vector<int> Omega(int L){
        int wn = qpow(G, mod / L, mod);
        vector<int> w(L); 
        w[L >> 1] = 1;
        for(int i = L / 2 + 1; i < L; i++) w[i] = mul(w[i - 1], wn);
        for(int i = L / 2 - 1; i >= 1; i--) w[i] = w[i << 1];
        return w;
    }
    auto W = Omega(1 << 21);

    void DIF(int *a, int n) {
        for(int k = n >> 1; k; k >>= 1)
            for(int i = 0, y; i < n; i += k << 1)
                for(int j = 0; j < k; j++){
                    y = a[i + j + k], a[i + j + k] = mul(a[i + j] - y + mod, W[k + j]), 
                    add(a[i + j], y);
                }
    }

    void IDIT(int *a, int n) {
        for (int k = 1; k < n; k <<= 1)
            for (int i = 0, x, y; i < n; i += k << 1)
                for(int j = 0; j < k; j++){
                    x = a[i + j], y = mul(a[i + j + k], W[k + j]),
                    a[i + j + k] = x - y < 0 ? x - y + mod : x - y;
                    add(a[i + j], y);
                }
        int inv = mod - (mod - 1) / n;
        for(int i = 0; i < n; i++) a[i] = mul(a[i], inv);
        reverse(a + 1, a + n);
    }
}

using Poly = std::vector<int>;

void DFT(Poly &a){
    NTT::DIF(a.data(), a.size());
}

void IDFT(Poly &a){
    NTT::IDIT(a.data(), a.size());
}

int normed(int n) { 
    return n == 1 ? 1 : (1 << (32 - __builtin_clz(n - 1))); 
}

void norm(Poly &a) { 
    if (!a.empty()) a.resize(normed((int)a.size()), 0); 
}

void dot(Poly &a, Poly &b) {
    for(int i = 0; i < a.size(); i++)
        a[i] = mul(a[i], b[i]);
}

Poly operator*(Poly a, Poly b) {
    int n = a.size() + b.size() - 1, L = normed(n);
    if (a.size() <= 8 || b.size() <= 8) {
        Poly c(n);
        for(int i = 0; i < a.size(); i++)
            for(int j = 0; j < b.size(); j++)
                c[i + j] = (c[i + j] + 1LL * a[i] * b[j]) % mod;
        return c;
    }
    a.resize(L), b.resize(L);
    DFT(a), DFT(b), dot(a, b), IDFT(a);
    return a.resize(n), a;
}

Poly MulAll(int l, int r, vector<Poly> &a){
    if (l > r) return {1};
    if (l == r) return a[r];
    int mid = (l + r) / 2;
    return MulAll(l, mid, a) * MulAll(mid + 1, r, a);
}

const int maxm = 2e5 + 5;
vector<pair<int, int> > g[maxn];
int dp[maxm][2];
int type[maxm];

void dfs(int u, int fa, int fa_type){
    vector<Poly> p[2];
    for(auto [j, w] : g[u]){
        if (j == fa) continue;
        dfs(j, u, w);
        p[w].push_back({dp[j][0], dp[j][1]});
    }
    auto a = MulAll(0, int(p[0].size()) - 1, p[0]);
    auto b = MulAll(0, int(p[1].size()) - 1, p[1]);
    int sza = a.size(), szb = b.size();
    for(int i = 0; i < min(sza, szb); i++){
        add(dp[u][0], mul(a[i], b[i]));
    }
    if (fa_type == -1){

    }
    else if (fa_type){
        // 可以上面换一个S下来,但是不与子树交换
        if (type[u] == 0){
            add(dp[u][1], dp[u][0]);
        }
        // 先与子树交换,再从上面换一个S下来,再与子树交换
        else{
            for(int i = 0; i < sza and i + 2 < szb; i++){
                add(dp[u][1], mul(a[i], b[i + 2]));
            }
        }
        // 上面送一个S下来,然后和某个子树里的F交换
        // 注意这总是可以的
        // 若u为S可以先与子树交换再与父亲交换
        // 若u为F可以先与父亲交换再与子树交换
        for(int i = 0; i < sza and i + 1 < szb; i++){
            add(dp[u][1], mul(a[i], b[i + 1]));
        }
    }
    else{
        if (type[u] == 1){
            add(dp[u][1], dp[u][0]);
        }
        else{
            for(int i = 0; i + 2 < sza and i < szb; i++){
                add(dp[u][1], mul(a[i + 2], b[i]));
            }
        }
        for(int i = 0; i + 1 < sza and i < szb; i++){
            add(dp[u][1], mul(a[i + 1], b[i]));
        }
    }
    if (type[u] == 1){
        for(int i = 0; i < sza and i + 1 < szb; i++){
            add(dp[u][0], mul(a[i], b[i + 1]));
        }    
    }
    else{
        for(int i = 0; i + 1 < sza and i < szb; i++){
            add(dp[u][0], mul(a[i + 1], b[i]));
        }
    }
}

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int n;
    cin >> n;
    for(int i = 1; i <= n; i++){
        char c;
        cin >> c;
        type[i] = (c == 'S');
    }
    for(int i = 0; i < n - 1; i++){
        int a, b;
        cin >> a >> b;
        g[a].push_back({b, 1});
        g[b].push_back({a, 0});
    }
    dfs(1, -1, -1);
    cout << dp[1][0] << '\n';

}