Problem:
Score : 700 points

Problem Statement

There is a tree with N vertices, numbered 1 through N.
The i-th of the N-1 edges connects vertices a_i and b_i.

Currently, there are A_i stones placed on vertex i.
Determine whether it is possible to remove all the stones from the vertices by repeatedly performing the following operation:

Select a pair of different leaves. Then, remove exactly one stone from every vertex on the path between those two vertices.
Here, a leaf is a vertex of the tree whose degree is 1, and the selected leaves themselves are also considered as vertices on the path connecting them.

Note that the operation cannot be performed if there is a vertex with no stone on the path.

Constraints

2 ≦ N ≦ 10^5

1 ≦ a_i,b_i ≦ N

0 ≦ A_i ≦ 10^9

The given graph is a tree.

Input

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

N
A_1 A_2 … A_N
a_1 b_1
:
a_{N-1} b_{N-1}

Output

If it is possible to remove all the stones from the vertices, print YES. Otherwise, print NO.

Sample Input 1

5
1 2 1 1 2
2 4
5 2
3 2
1 3

Sample Output 1

YES

All the stones can be removed, as follows:

Select vertices 4 and 5. Then, there is one stone remaining on each vertex except 4.

Select vertices 1 and 5. Then, there is no stone on any vertex.

Sample Input 2

3
1 2 1
1 2
2 3

Sample Output 2

NO

Sample Input 3

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

Sample Output 3

YES

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

#include <bits/stdc++.h>

using namespace std;

//頭の整理のためにコメントを入れてみる
//あってるかは知らない

typedef long long ll;
typedef vector< vector<int> > Graph;

Graph g;
ll a[100010];

//return: nodeとparentを結ぶ辺を通る操作の回数(通る回数)
//全ての石を取り除く事ができないと分かった場合-1を返す
ll dfs(int node, int parent) {
	//nodeが葉の場合通る回数は明らかにa[node]に等しい
	if (g[node].size() == 1) return a[node];

	ll c_sum = 0;  //nodeの子の通る回数の和
	ll c_max = 0;  //nodeの子の通る回数の最大値
	for (int nex : g[node]) {
		if (nex == parent) continue;
		ll c = dfs(nex, node);  //nodeの子の通る回数
		if (c == -1) return -1;  //全ての石を取り除く事ができないと分かった場合
		c_sum += c;
		c_max = max(c_max, c);
	}

	/* 
		T: nodeとparentを結ぶ辺を通る操作の回数
		L: nodeの異なる2つの子がnodeを経由してつながっている辺を通る操作の回数

		1.  nodeを経由するような辺は
			parent-node-children(パターンA)か
			children1-node-children2(パターンB)のどちらかしかなく
			いずれの場合も1回の操作でa[node]は1減る
			よって、a[node]を0にするためには
			T + L == a[node]が成立する必要がある

		2.  パターンAでは1回の操作で子の石は1つ減る
			一方、パターンBでは1回の操作で子の石は2つ減る
			以上よりnodeの子の石を全て0にするためには
			T + 2 * L == c_sumが成立する必要がある

		以上より
		1. T + L == a[node]
		2. T + 2 * L == c_sum
	*/
	ll T = 2 * a[node] - c_sum;
	ll L = c_sum - a[node];
	if (L < 0 || T < 0) return -1;

	/*
		nodeの異なる2つの子がnodeを経由してつながっている辺を通る操作の回数の最大値は

		1.  c_max > c_sum / 2の場合
			通る回数がc_maxとなるnodeの子とそれ以外のnodeの子全てをそれぞれペアとして
			各ペアをつなげた辺に対して操作をすると操作の回数を最大にでき、
			この時、通る回数がc_maxとなるnodeの子以外の石の数が0になることから
			操作の回数の最大値はc_sum - c_maxとなる

		2.  1以外の場合
			nodeの子の中で石の数が多いものを貪欲に2つ選び、
			それらをつなげた辺に対し操作を行うということを繰り返すことで
			操作の回数を最大にでき、
			この時、nodeの子の石の残りの合計はc_sum % 2となることから
			操作の回数の最大値はc_sum / 2となる

		Lが操作の回数の最大値を超えるなら-1を返す
	*/
	if (c_max > c_sum / 2) {
		if (L > c_sum - c_max) return -1;
		else return T;
	} else {
		if (L > c_sum / 2) return -1;
		else return T;
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	ll n;
	cin >> n;
	for (int i = 0; i < n; i++) cin >> a[i];
	g = Graph(n);
	for (int i = 0; i < n - 1; i++) {
		int s, d;
		cin >> s >> d;
		s--;
		d--;
		g[s].push_back(d);
		g[d].push_back(s);
	}

	/*
		YESを出力するのは
		根が葉の場合: dfs(root, -1) == a[root]
		根が葉ではない場合: dfs(root, -1) == 0
		今回は葉ではないノードを根とすることで後者の場合に統一
	*/

	//ノードが全て葉となる場合は例外として処理
	if (n == 2) {
		cout << (a[0] == a[1] ? "YES" : "NO") << endl;
		return 0;
	}

	//葉ではないノードを根とする
	int root;
	for (root = 0; root < n; root++) {
		if (g[root].size() != 1) break;
	}

	cout << (dfs(root, -1) == 0 ? "YES" : "NO") << endl;
	return 0;
}