///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//                       _oo0oo_                         //
//                      o8888888o                        //
//                      88" . "88      ------ hzt1       //
//                      (| -_- |)                        //
//                      0\  =  /0                        //
//                    ___/`---'\___                      //
//                  .' \|     |// '.                     //
//                 / \|||  :  |||// \                    //
//                / _||||| -:- |||||- \                  //
//               |   | \  -  /// |     |                 //
//               | \_|  ''\---/''  |_/ |                 //
//               \  .-\__  '-'  ___/-. /                 //
//             ___'. .'  /--.--\  `. .'___               //
//          ."" '<  `.___\_<|>_/___.' >' "".             //
//         | | :  `- \`.;`\ _ /`;.`/ - ` : | |           //
//         \  \ `_.   \_ __\ /__ _/   .-` /  /           //
//     =====`-.____`.___ \_____/___.-`___.-'=====        //
//                       `=---='                         //
//                                                       //
//                                                       //
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       //
//                                                       //
//                 God-He Bless All.                     //
//           This Code Will Never Explode.               //
//                                                       //
//                                                       //
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
/*
If all the nodes are available, we choose a range for each node that satisfies each node 
can't occupy all subtrees except for one only, and the whole tree meanwhile.
If any of the nodes is disabled, we give the donation of other nodes who covered it to itself.
*/
#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
#define rep(i,a,b) for(int i=(a),i##_end_=(b);i<=i##_end_;i++)
#define dwn(i,a,b) for(int i=(a),i##_end_=(b);i>=i##_end_;i--)
using namespace std;
const int Size=1<<16;
char buffer[Size],*head,*tail;
inline char Getchar() {
    if(head==tail) {
        int l=fread(buffer,1,Size,stdin);
        tail=(head=buffer)+l;
    }
    if(head==tail) return -1;
    return *head++;
}
inline int read() {
    int x=0,f=1;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*f;
}
typedef long long ll;
const int maxn=200010;
int n,first[maxn],nxt[maxn<<1],to[maxn<<1],e;
void AddEdge(int u,int v) {
	to[++e]=v;nxt[e]=first[u];first[u]=e;
	to[++e]=u;nxt[e]=first[v];first[v]=e;
}
int f[maxn],g[maxn],mx[maxn],se[maxn],siz[maxn],size;
char s[maxn];
void dfsin(int x,int fa) {
	siz[x]=s[x]=='1';
	for(int i=first[x];i;i=nxt[i]) if(to[i]!=fa) {
		dfsin(to[i],x);f[x]=max(f[x],f[to[i]]+1);
		if(f[to[i]]+1>se[x]) se[x]=f[to[i]]+1;
		if(se[x]>mx[x]) swap(mx[x],se[x]);
		siz[x]+=siz[to[i]];
	}
}
void dfsout(int x,int fa) {
	for(int i=first[x];i;i=nxt[i]) if(to[i]!=fa) {
		g[to[i]]=max(f[to[i]]+1==mx[x]?se[x]:mx[x],g[x])+1;
		dfsout(to[i],x);
	}	
}
ll solve(int x,int fa) {
	if(g[x]>se[x]) se[x]=g[x];
	if(se[x]>mx[x]) swap(mx[x],se[x]);
	ll ans=0;int mn=min(mx[x],se[x]+2);
	for(int i=first[x];i;i=nxt[i]) if(to[i]!=fa) {
		ans+=solve(to[i],x);
		if(siz[to[i]]) mn=min(mn,f[to[i]]+1);
	}
	if(size-siz[x]) mn=min(mn,g[x]);
	if(s[x]=='1') mn=0;
	return ans+min(mx[x],se[x]+2)-mn;
}
int main() {
	n=read();
	rep(i,2,n) AddEdge(read(),read());
	scanf("%s",s+1);
	dfsin(1,0);dfsout(1,0);
	rep(i,1,n) if(s[i]=='1') size++;
	printf("%lld\n",solve(1,0)+1);
	return 0;
}
