#include <bits/stdc++.h>
using namespace std;

using VS = vector<string>;    using LL = long long;
using VI = vector<int>;       using VVI = vector<VI>;
using PII = pair<int, int>;   using PLL = pair<LL, LL>;
using VL = vector<LL>;        using VVL = vector<VL>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)-form-)
//#pragma GCC optimize ("-O3") 
#ifdef YANG33
#include "mydebug.hpp"
#else
#define DD(x) 
#endif
const int INF = 1e9;                          const LL LINF = 1e16;
const LL MOD = 1000000007;                    const double PI = acos(-1.0);
int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };


inline int ri() { int in; int y = scanf("%d", &in); return in; }
inline void oi(int i) { printf("%d\n", i); }
inline void od(double i) { printf("%.9f\n", i); }


template<typename E>
struct TreeDiameter {
	int N;
	vector<vector<E>>G;
	vector<LL> vw;
	TreeDiameter(const vector<vector<E>>& g, const vector<LL> &a = {}) : N(int(g.size())), G(g) {
		if ((int)a.size())vw = a;
		else vw = VL(N, 0);
	}
	PLL dfs(int v, int p) {
		PLL ret = PLL(0, v);
		for (auto u : G[v]) {
			int nx = u.to;
			if (nx == p)continue;
			PLL temp = dfs(nx, v);
			LL ecost = u.cost;
			temp.first += ecost;
			ret = max(ret, temp);
		}
		ret.first += vw[v];
		return ret;
	}

	pair<LL, PLL> build(int root) {
		PLL p = dfs(root, -1);
		PLL q = dfs(p.second, -1);
		return pair<LL, PLL>(q.first, PLL(p.second, q.second));
	}
};

template<typename E>
pair<LL, PLL> getTreeDiameter(const int root, const vector<vector<E>>& G, const vector<LL>& v = {}) {
	return TreeDiameter<E>(G, v).build(root);
}// 微妙らしい

void solve_ARC097_F() {
	int N = ri();
	struct Edge
	{
		int to;
		int cost;
		Edge(int t, int c = 0) :to(t), cost(c) {}
	};

	vector<vector<Edge>>G(N);
	vector<int>deg(N, 0);
	FOR(i, 0, N - 1) {
		int s = ri() - 1, t = ri() - 1;
		G[s].push_back(Edge(t));
		G[t].push_back(Edge(s));
		deg[s]++;
		deg[t]++;
	}
	string s; cin >> s;

	// Gの更新
	VI nouse(N, 0);
	// nouseを決める
	{
		queue<int>q;
		FOR(i, 0, N) {
			if (deg[i] <= 1 && s[i] == 'B') {
				q.push(i);
				nouse[i] = 1;
			}
		}
		// black and deg==1を消す
		// トポソのノリ
		while (!q.empty()) {
			int v = q.front(); q.pop();
			for (auto u : G[v]) {
				int nx = u.to;
				if (nouse[nx])continue;
				deg[nx]--;
				if (deg[nx] <= 1 && s[nx] == 'B') {
					nouse[nx] = 1;
					q.push(nx);
				}
			}
		}
	}

	int root = -1;
	{
		// 残ったグラフの頂点のひとつをrootにする
		FOR(i, 0, N) {
			if (!nouse[i])root = i;
		}
		DD(De(nouse));
		// nouseじゃない辺なら張るをする
		vector<vector<Edge>>nxG(N); {
			FOR(v, 0, N) {
				for (auto u : G[v]) {
					int nx = u.to;
					if (!nouse[v] && !nouse[nx]) {
						nxG[v].push_back(Edge(nx));
					}
				}
			}
		}

		G = nxG;
	}
	// 適用できない場合
	if (accumulate(ALL(nouse), 0LL) >= N - 2) {
		cout << N - accumulate(ALL(nouse), 0LL) << endl;
		DD(de("end"));
		return;
	}
	DD(de(root));
	int tourcost = 0;
	// Gの巡回コスト
	VL co(N);
	{
		function<int(int, int)>f = [&](int v, int p) {
			int deg = SZ(G[v]);
			int ret = (deg & 1) ^ (s[v] == 'W');
			co[v] = ret;
			DD(de(v, deg, s[v], ret));
			for (auto nx : G[v]) {
				if (nx.to == p)continue;
				ret += f(nx.to, v) + 2;
			}
			return ret;
		};
		tourcost = f(root, -1);
	}
	DD(de(tourcost));
	// Gの取れる最大パス長
	TreeDiameter<Edge> Tree(G, co);
	int mx = Tree.build(root).first;
	//int mx = getTreeDiameter(root, G, co).first;
	// ans
	DD(de(tourcost, mx));
	oi(tourcost - 2 * mx); // 式変形をするとでる


	//int mx = 0;
	// カス

	// あらかじめ頂点のアレわかるんだから頂点ベースの直径で求められないか
	//if (0) { // だみだこり: 有向グラフをうまくあつかえない…
	//	struct Node {
	//		PII top2;
	//		int childs;
	//		Node(PII e = PII(-INF, -INF), int c = 0) :top2(e), childs(c) {}
	//		Node include_e(int, const Edge&e) const {
	//			// e.toがアレ．
	//			int nx = e.to;
	//			int deg = childs + 1;
	//			int cost = (deg & 1) ^ (s[nx] == 'W');
	//			if (!cost)cost = -1;
	//			DD(de("to:", nx, cost, deg));
	//			return Node(PII(max(0, top2.first + cost), 0), 1);
	//		}

	//		Node operator + (const Node& r) const {
	//			PII res = top2;
	//			for (auto it : { r.top2.first,r.top2.second }) {
	//				if (res.first < it) {
	//					res.second = res.first;
	//					res.first = it;
	//				}
	//				else if (res.second < it) {
	//					res.second = it;
	//				}
	//			}
	//			return Node(res, childs + r.childs);
	//		}
	//		Node include_v(int) const {
	//			return *this;
	//		}
	//	};

	//	auto tree_res = Rerooting_get<Node>(G);
	//	FOR(i, 0, N) {
	//		if (nouse[i])continue;
	//		Node it = tree_res[i].back();
	//		DD(de(i + 1, it.top2.first, it.top2.second, it.childs));
	//		mx = max(mx, it.top2.first);
	//		mx = max(mx, it.top2.first + it.top2.second);
	//	}
	//}

}
int main() {
	solve_ARC097_F();
}


Measured memory_bytes: 24024