#include <bits/stdc++.h>

using std::vector, std::array, std::string;
using std::set, std::map, std::multiset;
using std::min, std::max, std::swap;
using std::pair, std::tuple;
using std::tie;
using std::abs, std::sin, std::cos, std::tan, std::asin, std::acos, std::atan2;
using std::cin, std::cout, std::cerr, std::endl;

template <class T> using Vec = vector<T>;
template <class T> using Opt = std::optional<T>;

using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
using u128 = __uint128_t;

std::mt19937_64 mt(std::chrono::steady_clock::now().time_since_epoch().count());

template <class T> T pow(T a, i64 b) {
	assert(b >= 0);
	T r = 1;
	while (b) {
		if (b & 1) r *= a;
		a *= a;
		b >>= 1;
	}
	return r;
}

template <u32 mod> struct ModInt {
	using mint = ModInt;
	static constexpr u32 m = mod;
	u32 v;
	constexpr ModInt() : v(0) {}
	template <class T> constexpr ModInt(T a) { s(u32(a % m + m)); }
	constexpr mint& s(u32 a) { v = a < m ? a : a-m; return *this; }
	friend mint inv(const mint& n) { return pow(n, m-2); }

	mint operator- () const {
		mint res;
		res.v = v ? m-v : 0;
		return res;
	}

	friend bool operator == (const mint& a, const mint& b) { return a.v == b.v; }
	friend bool operator != (const mint& a, const mint& b) { return !(a == b); }

	mint& operator += (const mint& o) { return s(v + o.v); }
	mint& operator -= (const mint& o) { return s(v + m - o.v); }
	mint& operator *= (const mint& o) { v = u32(u64(v) * o.v % m); return *this; }
	mint& operator /= (const mint& o) { return *this *= inv(o); }

	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; }

	static constexpr u32 get_mod() { return m; }
	static constexpr mint get_root() {
		if (m == 998244353) return 3;
		assert(false);
	}
};

template <class T> void nft(Vec<T>& a, int n) {
	static Vec<int> rev = {0, 1};
	static Vec<T> rt(2, 1);
	if (int(size(rt)) < n) {
		rev.resize(n);
		for (int i = 0; i < n; i++) {
			rev[i] = (rev[i>>1] | ((i&1)*n)) >> 1;
		}
		rt.reserve(n);
		for (int k = int(size(rt)); k < n; k *= 2) {
			rt.resize(2*k);
			T z = pow(T::get_root(), (T::get_mod()-1) / (2*k));
			for (int i = k/2; i < k; i++) {
				rt[2*i] = rt[i];
				rt[2*i+1] = rt[i] * z;
			}
		}
	}
	int s = std::countr_zero(u32(rev.size()) / n);
	for (int i = 0; i < n; i++) {
		int j = rev[i] >> s;
		if (i < j) swap(a[i], a[j]);
	}
	for (int k = 1; k < n; k *= 2) {
		for (int i = 0; i < n; i += 2*k) {
			auto it1 = begin(a) + i;
			auto it2 = it1 + k;
			for (int j = 0; j < k; j++, ++it1, ++it2) {
				T t = rt[j+k] * *it2;
				*it2 = *it1 - t;
				*it1 += t;
			}
		}
	}
}

template <class T> Vec<T> multiply(Vec<T> a, Vec<T> b) {
	const int n = int(size(a));
	const int m = int(size(b));
	if (!n || !m) return {};
	const int s = std::bit_ceil<u32>(n + m - 1);
	a.resize(s), nft(a, s);
	b.resize(s), nft(b, s);
	T is = inv(T(s));
	for (int i = 0; i < s; i++) {
		a[i] *= b[i] * is;
	}
	reverse(begin(a) + 1, end(a));
	nft(a, s);
	a.resize(n + m - 1);
	return a;
}

template <class T> Vec<T> multiply_all(const Vec<Vec<T>>& pols) {
	if (pols.empty()) {
		// identity?
		return {T(1)};
	}
	auto rec = [&](auto self, int l, int r) -> Vec<T> {
		if (l+1 == r) {
			return pols[l];
		}
		int m = (l+r) >> 1;
		return multiply(self(self, l, m), self(self, m, r));
	};
	return rec(rec, 0, int(size(pols)));
}

int main() {
	std::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	int N;
	cin >> N;

	string label;
	cin >> label;

	auto adj = Vec<Vec<pair<int, bool>>>(N);
	for (int e = 0; e < N-1; e++) {
		int a, b;
		cin >> a >> b;
		a--, b--;
		// true = forward, false = backward
		adj[a].emplace_back(b, true);
		adj[b].emplace_back(a, false);
	}

	using Z = ModInt<998244353>;
	using Result = array<Z, 3>;

	auto dfs = [&](auto self, int cur, int prv) -> Result {
		auto ch_pols = Vec<Vec<Z>>();
		int offset = 0;
		for (auto [nxt, dir] : adj[cur]) {
			if (nxt == prv) {
				continue;
			}
			auto ch_result = self(self, nxt, cur);
			if (dir) {
				// forward
				ch_pols.push_back(Vec<Z>{ch_result[1], ch_result[2]});
			} else {
				// backward
				offset--;
				ch_pols.push_back(Vec<Z>{ch_result[0], ch_result[1]});
			}
		}

		auto result = Result();
		auto prod = multiply_all(ch_pols);
		for (int z = 0; z < int(size(prod)); z++) {
			int b = z + offset;
			for (int k : {b, b + (label[cur] == 'S' ? -1 : 1)}) {
				if (-1 <= k && k <= 1) {
					result[k+1] += prod[z];
				}
			}
		}
		return result;
	};
	auto result = dfs(dfs, 0, -1);
	cout << result[1].v << '\n';

	return 0;
}