// This Code was made by Chinese_zjc_.
#include <bits/stdc++.h>
const int MOD = 998244353;
struct mint
{
    unsigned v;
    mint(unsigned v_ = 0) : v(v_) {}
    mint operator-() const { return v ? MOD - v : *this; }
    mint &operator+=(const mint &X) { return (v += X.v) >= MOD ? v -= MOD : v, *this; }
    mint &operator-=(const mint &X) { return (v += MOD - X.v) >= MOD ? v -= MOD : v, *this; }
    mint &operator*=(const mint &X) { return v = 1llu * v * X.v % MOD, *this; }
    mint &operator/=(const mint &X) { return *this *= X.inv(); }
    mint pow(long long B) const
    {
        B %= MOD - 1;
        if (B < 0)
            B += MOD - 1;
        mint res = 1, A = *this;
        while (B)
        {
            if (B & 1)
                res *= A;
            B >>= 1;
            A *= A;
        }
        return res;
    }
    mint inv() const { return pow(MOD - 2); }
    friend mint operator+(const mint &A, const mint &B) { return mint(A) += B; }
    friend mint operator-(const mint &A, const mint &B) { return mint(A) -= B; }
    friend mint operator*(const mint &A, const mint &B) { return mint(A) *= B; }
    friend mint operator/(const mint &A, const mint &B) { return mint(A) /= B; }
    friend std::istream &operator>>(std::istream &A, mint &B) { return A >> B.v; }
    friend std::ostream &operator<<(std::ostream &A, const mint &B) { return A << B.v; }
    explicit operator bool() const { return v; }
} dp[200005][2];
typedef std::vector<mint> poly;
void NTT(poly &X)
{
    static std::vector<std::size_t> rev;
    if (rev.size() != X.size())
    {
        rev.resize(X.size());
        for (std::size_t i = 0; i != rev.size(); ++i)
            rev[i] = (rev[i >> 1] | (i & 1 ? rev.size() : 0)) >> 1;
    }
    for (std::size_t i = 0; i != X.size(); ++i)
        if (rev[i] < i)
            std::swap(X[rev[i]], X[i]);
    for (std::size_t i = 1; i != X.size(); i <<= 1)
    {
        mint w = mint(3).pow((MOD - 1) / 2 / i);
        for (std::size_t j = 0; j != X.size(); j += i << 1)
        {
            mint v = 1;
            for (std::size_t k = 0; k != i; ++k, v *= w)
            {
                mint A = X[j + k], B = v * X[i + j + k];
                X[j + k] = A + B;
                X[i + j + k] = A - B;
            }
        }
    }
}
void INTT(poly &X)
{
    NTT(X);
    std::reverse(X.begin() + 1, X.end());
    mint inv = mint(X.size()).inv();
    for (auto &i : X)
        i *= inv;
}
int up(int v) { return v - 1 ? 1 << (32 - __builtin_clz(v - 1)) : v; }
poly operator*(poly A, poly B)
{
    int len = A.size() + B.size() - 1;
    poly res(up(len));
    A.resize(res.size());
    B.resize(res.size());
    NTT(A);
    NTT(B);
    for (std::size_t i = 0; i != res.size(); ++i)
        res[i] = A[i] * B[i];
    INTT(res);
    res.resize(len);
    return res;
}
int n, u[200005], v[200005], fe[200005];
bool s[200005];
std::vector<int> to[200005];
std::pair<poly, int> solve(std::vector<int>::iterator l, std::vector<int>::iterator r, int now)
{
    if (l == r)
        return {{1}, 0};
    if (r - l == 1)
    {
        int t = u[*l] ^ v[*l] ^ now;
        if (v[*l] == t)
            return {{dp[t][0], dp[t][1]}, 0};
        else
            return {{dp[t][1], dp[t][0]}, -1};
    }
    std::vector<int>::iterator mid = l + (r - l) / 2;
    std::pair<poly, int> L = solve(l, mid, now), R = solve(mid, r, now);
    return {L.first * R.first, L.second + R.second};
}
void dfs(int now)
{
    for (std::size_t i = 0; i != to[now].size(); ++i)
    {
        if (to[now][i] == fe[now])
        {
            std::swap(to[now][i--], to[now].back());
            to[now].pop_back();
            continue;
        }
        int t = u[to[now][i]] ^ v[to[now][i]] ^ now;
        fe[t] = to[now][i];
        dfs(t);
    }
    std::pair<poly, int> res = solve(to[now].begin(), to[now].end(), now);
    for (int i = 0; i != 2; ++i)
    {
        int r = s[now] + (v[fe[now]] == now ? +i : -i);
        for (int j = 0; j != 2; ++j)
        {
            int p = r - j;
            if (p - res.second >= 0 && p - res.second < int(res.first.size()))
                dp[now][i] += res.first[p - res.second];
        }
    }
    // std::cout << now << ' ' << dp[now][0] << std::endl;
    // std::cout << res.second << std::endl;
    // for (auto i : res.first)
    //     std::cout << i << ' ';
    // std::cout << std::endl;
}
signed main()
{
    std::ios::sync_with_stdio(false);
    std::cin >> n;
    for (int i = 1; i <= n; ++i)
    {
        static char c;
        std::cin >> c;
        s[i] = c == 'S';
    }
    for (int i = 1; i != n; ++i)
    {
        std::cin >> u[i] >> v[i];
        to[u[i]].push_back(i);
        to[v[i]].push_back(i);
    }
    dfs(1);
    std::cout << dp[1][0] << std::endl;
    return 0;
}