//marico el que lo lea
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <assert.h>
using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> ii;

void fastIO() {std::ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);}

#define pb push_back
#define all(obj) obj.begin(), obj.end()
#define ms(obj, val) memset(obj, val, sizeof(obj))
#define ms2(obj, val, sz) memset(obj, val, sizeof(obj[0])*sz)

#define fst first
#define snd second

template<typename T, typename U> inline void mnze(T &x, U y) {if(y < x) x = y;}
template<typename T, typename U> inline void mxze(T &x, U y) {if(x < y) x = y;}

void _scan( int &x ) { scanf("%d",&x); }
void _scan( long long &x ) { scanf("%lld",&x); }
void _scan( double &x ) { scanf("%lf",&x); }
void _scan( char &x ) { scanf(" %c",&x); }
void _scan( char *x ) { scanf("%s",x); }
template<typename T>
void _scan( vector<T> &v ){
	for(int i=0; i<(int)v.size(); i++) _scan(v[i]);
}
void scan() {}
template<typename T, typename... U>
void scan( T& head, U&... tail ) { _scan(head); scan(tail...);}

template<typename T> void _dbg(const char* sdbg, T h)
	{ cerr<<sdbg<<"="<<h<<"\n"; }
template<typename T, typename... U> void _dbg(const char* sdbg, T h, U... t) {
	while(*sdbg != ',')cerr<<*sdbg++;
	cerr<<"="<<h<<","; _dbg(sdbg+1, t...);
}

#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#define debugv(x) {{cerr<<#x<<" = "; for(auto _i:x) cerr<<_i<<", ";cerr<<"\n";}}
#define debuga(x, sz) {{cerr<<#x<<" = ";for(int _i=0;_i<sz;_i++)cerr<<x[_i]<<", ";cerr<<"\n";}}
#else
#define debug(...) (__VA_ARGS__)
#define debugv(x)
#define debuga(x, sz)
#define cerr if(0)cout
#endif

ll MOD = 1e9+7;

inline ll Msum(ll x){return x;}
template<typename... Rest>
inline ll Msum(ll x, Rest... rest){ return (x + Msum(rest...)) % MOD; }

inline ll Mprod(ll x){return x;}
template<typename... Rest>
inline ll Mprod(ll x, Rest... rest){ return x * Mprod(rest...) % MOD; }

inline ll Mnorm(ll x){ return (x%MOD + MOD) %MOD; }

inline ll Msq(ll x){ return (x*x) %MOD; }
inline ll Mpot(ll x, ll e){
	if(!e) return 1;
	return Msq(Mpot(x, e>>1)) * (e & 1 ? x : 1)%MOD;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

const int MAXN = 1e5+5;
const int INF = 0x3f3f3f3f;
char aux[MAXN];

int n, c[MAXN], pp[MAXN];
bool inG[MAXN];


vi tG[MAXN], G[MAXN];
int csz[MAXN];


int deg(int v){return G[v].size();}
int c1(int v){
	return deg(v) + (c[v] + deg(v))%2;
}
int c2(int v){
	return deg(v)-1 + (c[v] + deg(v)+1)%2;
}

void dfstree(int v, int p){
	csz[v] = c[v];
	pp[v] = p;
	for(int u : tG[v]){
		if(u == p) continue;
		dfstree(u, v);
		if(csz[u]){
			csz[v] += csz[u];
			G[v].pb(u);
			G[u].pb(v);
		}
	}
	inG[v] = csz[v]>0;
}

multiset<int> dpaths[MAXN];
int dpd[MAXN];
void fd(int v){
	dpd[v] = 0;
	dpaths[v].insert(0);
	for(int u : G[v]){
		if(u == pp[v]) continue;
		fd(u);
		int nret = c2(v)-c1(v) + dpd[u];
		dpaths[v].insert(nret);
		mnze(dpd[v], nret);
	}
}

int pu[MAXN];
void fu(int v){
	pu[v] = 0;
	if(pp[v] != -1){
		int p = pp[v];
		mnze(pu[v], c2(v)-c1(v) + pu[p]);

		int pd = c2(p)-c1(p) + dpd[v];
		auto it = dpaths[p].begin();
		if(*it != pd) mnze(pu[v], c2(v)-c1(v) + *it);
		else{
			it++;
			if(it != dpaths[p].end()) mnze(pu[v], c2(v)-c1(v) + *it);
		}
	}
	for(int u : G[v]){
		if(u == pp[v]) continue;
		fu(u);
	}
}

int main(){
	scan(n);
	for(int i=0; i<n-1; i++){
		int v, u; scan(v, u); v--; u--;
		tG[v].pb(u);
		tG[u].pb(v);
	}
	scan(aux);
	for(int i=0; i<n; i++) c[i] = (aux[i] == 'W');

	int ws=-1;
	for(int i=0; i<n; i++){
		if(c[i]){
			dfstree(i, -1);
			ws=i;
			break;
		}
	}
	if(ws==-1){
		printf("0\n");
		return 0;
	}
	int ans0=0;
	for(int i=0; i<n; i++) if(inG[i]){
		ans0 += c1(i);
	}
	//debug(ans0);
	int ans = ans0;

	//for(int i=0; i<n; i++) if(inG[i]){
		//debug(i+1, c1(i), c2(i), c2(i)-c1(i));
	//}

	fd(ws);
	fu(ws);
	for(int i=0; i<n; i++) if(inG[i]){
		//debug(i+1, dpd[i], pu[i]);
		mnze(ans, ans0 + dpd[i]);
		mnze(ans, ans0 + pu[i]);
	}
	printf("%d\n", ans);

}


Measured memory_bytes: 35200