Problem:
Score : 1900 points

Problem Statement

There is a tree with N vertices.
The vertices are numbered 1 through N.
For each 1 ≤ i ≤ N - 1, the i-th edge connects vertices a_i and b_i.
The lengths of all the edges are 1.

Snuke likes some of the vertices.
The information on his favorite vertices are given to you as a string s of length N.
For each 1 ≤ i ≤ N, s_i is 1 if Snuke likes vertex i, and 0 if he does not like vertex i.

Initially, all the vertices are white.
Snuke will perform the following operation exactly once:

Select a vertex v that he likes, and a non-negative integer d. Then, paint all the vertices black whose distances from v are at most d.

Find the number of the possible combinations of colors of the vertices after the operation.

Constraints

2 ≤ N ≤ 2×10^5

1 ≤ a_i, b_i ≤ N

The given graph is a tree.

|s| = N

s consists of 0 and 1.

s contains at least one occurrence of 1.

Partial Score

In the test set worth 1300 points, s consists only of 1.

Input

The input is given from Standard Input in the following format:

N
a_1 b_1
a_2 b_2
:
a_{N - 1} b_{N - 1}
s

Output

Print the number of the possible combinations of colors of the vertices after the operation.

Sample Input 1

4
1 2
1 3
1 4
1100

Sample Output 1

4

The following four combinations of colors of the vertices are possible:

Sample Input 2

5
1 2
1 3
1 4
4 5
11111

Sample Output 2

11

This case satisfies the additional constraint for the partial score.

Sample Input 3

6
1 2
1 3
1 4
2 5
2 6
100011

Sample Output 3

8

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <algorithm>
#define rep(i, a, b) for (int i = (a), _ = (b); i <= _; ++ i)
#define per(i, a, b) for (int i = (a), _ = (b); i >= _; -- i)
#define For(i, a, b) for (int i = (a), _ = (b); i < _; ++ i)
#define fore(e, u, v) for (int p = e(u), v = e[p].y; p; v = e[p = e[p].nxt].y)
#define ri rd<int>
using namespace std;
typedef long long LL;
const int maxN = 2e5 + 7;
const int INF = 1e9 + 7;

template<class T> inline T rd() {
	bool f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == '-') f = 0;
	T x = 0; for (; isdigit(c); c = getchar()) x = x * 10 + c - 48; return f ? x : -x;
}

int n;
int depth[maxN];
int sz[maxN], tot;
LL ans;

char s[maxN];
struct Vec {
	static const int maxE = maxN;
	int g[maxN], te; 
	struct edge {int y, nxt;} e[maxE << 1];
	inline void push(int x, int y) { e[++te] = (edge){y, g[x]}; g[x] = te; }
	inline void link(int x, int y) { push(x, y), push(y, x); }
	inline int& operator () (int x) { return g[x]; }
	inline edge& operator [] (int x) { return e[x]; }
}e;

void dfs1(int x, int fa) {
	depth[x] = 1;
	sz[x] = s[x] == '1';
	fore (e, x, y) if (y != fa) {
		dfs1(y, x);
		depth[x] = max(depth[x], depth[y] + 1);
		sz[x] += sz[y];
	}
}

void dfs2(int x, int fa) {
	int mx = 0, sec = 0, id = 0, least = s[x] == '1' ? 0 : INF;
	fore (e, x, y) {
		if (depth[y] > mx) sec = mx, mx = depth[y], id = y;
		else if (depth[y] > sec) sec = depth[y];
		if (s[x] == '0' && sz[y]) least = min(least, depth[y]);
	}
	ans += max(0, min(mx-1, sec+1) - least + 1);
	fore (e, x, y) if (y != fa) {
		sz[x] = tot - sz[y];
		if (y != id) depth[x] = mx+1, dfs2(y, x);
		else depth[x] = sec+1, dfs2(y, x);
	}
}

int main() {
	n = ri();
	For (i, 1, n) e.link(ri(), ri());
	scanf("%s", s+1);
	rep (i, 1, n) if (s[i] == '1') ++ tot;

	dfs1(1, 0);
	dfs2(1, 0);

	printf("%lld\n", ans+1);

	return 0;
}