#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define lowbit(x) (x&-x)
#define log(x) (31^__builtin_clz(x))
using namespace std;

const int mod = 998244353, gen = 3;
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 {
    vector<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(vector<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);
                }
            }
        }
    }
    vector<int> operator *(vector<int> f, vector<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 *;

const int maxn=2e5+5,p=998244353;
ll dp[maxn][4];
int a[maxn];
vector<pii>e[maxn];
vector<int> calc(vector<pii>&t,int l,int r){
    if(t.empty())return{1};
    if(l==r)return{t[l].first,t[l].second};
    int mid=l+r>>1;
    return calc(t,l,mid)*calc(t,mid+1,r);
}
void dfs(int x,int f){
    vector<pii>add,dec;
    vector<int>dp1,dp2,dp3;
    for(auto u:e[x]){
        int v=u.first;
        if(v==f)continue;
        dfs(v,x);
        if(u.second==1){
            dec.push_back({(dp[v][1]+dp[v][2])%p,(dp[v][0]+dp[v][1])%p});
        }
        else{
            add.push_back({(dp[v][1]+dp[v][2])%p,(dp[v][2]+dp[v][3])%p});
        }
    }
    dp1=calc(add,0,(int)add.size()-1);
    dp2=calc(dec,0,(int)dec.size()-1);
    reverse(dp2.begin(),dp2.end());
    int siz=dec.size()+1;
    if(a[x])dp3={0,0,1};
    else dp3={0,1,0};
    dp3=dp1*dp2*dp3;
    dp3.resize(siz+3);
    for(int i=0;i<4;i++)if(siz+i-1>=0)dp[x][i]=dp3[siz+i-1];
    // cout<<"Point = "<<x<<" "<<siz<<" "<<dp3.size()<<"\n";
    // for(auto u:dp3)cout<<u<<" ";cout<<"dec\n";
    // for(int i=0;i<=3;i++)cout<<dp[x][i]<<" ";cout<<"\n";
}
void solve(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        char c;
        cin>>c;
        a[i]=c=='S';
    }
    for(int i=1;i<n;i++){
        int u,v;
        cin>>u>>v;
        e[u].push_back({v,1});
        e[v].push_back({u,0});
    }
    dfs(1,0);
    cout<<(dp[1][1]+dp[1][2])%p<<"\n";
}
int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t=1;
    // cin>>t;
    while(t--)solve();
    return 0;
}
/*

*/