#include<bits/stdc++.h>
using namespace std;
#define V vector
#define pb push_back


typedef long long LL;
typedef pair<int, int> pi;

const int mod = 998244353, gen = 3;
LL qpow(int x, LL k) {
    LL ans = 1;
    while(k) {
        if(k & 1) ans = ans * x % mod;
        k >>= 1;
        x = 1LL * x * x % mod;
    }
    return ans;
}
inline int power(int x, int y) {
    int res = 1;
    for(; y; y >>= 1, x = 1LL * x * x % mod) {
        if(y & 1) { res = 1LL * res * x % mod; }
    }
    return res;
}
inline int add(int x, int y) {
    return x + y >= mod ? x + y - mod : x + y;
}
inline int sub(int x, int y) {
    return x - y >= 0 ? x - y : x - y + mod;
}

namespace Polynom {
    V<int> rev, rt;

    void getRevRoot(int n) {
        int m = __lg(n);
        rev.resize(n);
        for( int i = 1; i < n; i++) {
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << m - 1;
        }
        static int len = 1;
        if(len < n) {
            rt.resize(n);
            for(; len < n; len *= 2) {
                int uni = power(gen, (mod - 1) / (len * 2));
                rt[len] = 1;
                for (int i = 1; i < len; i++) {
                    rt[i + len] = 1LL * rt[i + len - 1] * uni % mod;
                }
            }
        }
    }

    void ntt(V<int> &f, int n) {
        f.resize(n);
        for(int i = 0; i < n; i++) {
            if (i < rev[i]) { swap(f[i], f[rev[i]]); }
        }
        for (int len = 1; len < n; len *= 2) {
            for(int i = 0; i < n; i += len * 2) {
                for(int j = 0; j < len; j++) {
                    int x = f[i + j], y = 1LL * f[i + j + len] * rt[j + len] % mod;
                    f[i + j] = add(x, y); f[i + j + len] = sub(x, y);
                }
            }
        }
    }

    V<int> operator*(V<int> f, V<int> g) {
        int n = 1, m = f.size() + g.size(); m--;
        while(n < m) {n *= 2; }
        int invn = power(n, mod - 2);
        getRevRoot(n); ntt(f, n), ntt(g, n);
        for(int i = 0; i < n; i++) {f[i] = 1LL * f[i] * g[i] % mod;}
        reverse(f.begin() + 1, f.end());
        ntt(f, n); f.resize(m);
        for(int i = 0; i < m; i++) f[i] = 1LL * f[i] * invn % mod;
        return f;
    }
}

using Polynom::operator*;

V<int> mul(int l, int r, V<V<int>>& v) {
    if(l == r) return v[l];
    int mid = l + r >> 1;
    return mul(l, mid, v) * mul(mid + 1, r, v);
}

void solve() {
    int n; cin >> n;
    string s; cin >> s;
    s = " " + s;
    V<V<pi>> e(n + 1);
    for(int i = 1; i < n; i++) {
        int a, b; cin >> a >> b;
        e[a].pb({b, 0});
        e[b].pb({a, 1});
    }
    // auto x = V<int>{1, 1} * V<int>{1, 1};
    // for(auto y : x) cout << y << " ";
    // cout << endl;
    V<V<int>> dp(2, V<int>(n + 1));
    auto dfs = [&](int x, int p, int pdir, auto dfs) -> void {
        V<V<int>> to_mul;
        int minus = 0;
        for(auto [y, dir] : e[x]) {
            if(y == p) continue;
            dfs(y, x, dir, dfs);
            if(!dir) to_mul.pb({dp[1][y], dp[0][y]}), minus++;
            else to_mul.pb({dp[0][y], dp[1][y]});
        }
        to_mul.pb({1});
        auto ans = mul(0, to_mul.size() - 1, to_mul);
        if(s[x] == 'S') minus--;
        int hav0 = 0, hav1 = 0, hav2 = 0, havm1 = 0;
        if(minus >= 0 && minus < ans.size()) hav0 = ans[minus];
        if(minus + 1 >= 0 && minus + 1 < ans.size()) hav1 = ans[minus + 1];
        if(minus + 2 >= 0 && minus + 2 < ans.size()) hav2 = ans[minus + 2];
        if(minus - 1 >= 0 && minus - 1 < ans.size()) havm1 = ans[minus - 1];

        dp[0][x] = hav0 + hav1;
        if(dp[0][x] >= mod) dp[0][x] -= mod;

        dp[1][x] = pdir ? hav1 + hav2: hav0 + havm1;
        if(dp[1][x] >= mod) dp[1][x] -= mod;


        // cout << "x : " << x << endl;
        // for(auto y : ans) cout << y << " ";
        // cout << endl;
        // cout << dp[0][x] << " " << dp[1][x] << endl;
    };
    dfs(1, 0, 0, dfs);
    cout << dp[0][1] << endl;
    
}
int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    // int t; cin >> t;
    // while(t--) solve();
    solve();
}