#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

#define REP(i,n) for(long long i = 0; i < (n); i++)
#define FOR(i, m, n) for(long long i = (m);i < (n); ++i)
#define ALL(obj) (obj).begin(),(obj).end()

template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;

const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll LLINF = (ll)1e18;
const ll INTINF = (ll)1e9;
const long double PI = 3.1415926535897932384626433;

template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template <class T, class U>ostream &operator<<(ostream &o, const map<T, U>&obj) {o << "{"; for (auto &x : obj) o << " {" << x.first << " : " << x.second << "}" << ","; o << " }"; return o;}
template <class T>ostream &operator<<(ostream &o, const set<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const multiset<T>&obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr) o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
template <class T>ostream &operator<<(ostream &o, const vector<T>&obj) {o << "{"; for (int i = 0; i < (int)obj.size(); ++i)o << (i > 0 ? ", " : "") << obj[i]; o << "}"; return o;}
template <class T, class U>ostream &operator<<(ostream &o, const pair<T, U>&obj) {o << "{" << obj.first << ", " << obj.second << "}"; return o;}
template <template <class tmp>  class T, class U> ostream &operator<<(ostream &o, const T<U> &obj) {o << "{"; for (auto itr = obj.begin(); itr != obj.end(); ++itr)o << (itr != obj.begin() ? ", " : "") << *itr; o << "}"; return o;}
void print(void) {cout << endl;}
template <class Head> void print(Head&& head) {cout << head;print();}
template <class Head, class... Tail> void print(Head&& head, Tail&&... tail) {cout << head << " ";print(forward<Tail>(tail)...);}
template <class T> void chmax(T& a, const T b){a=max<T>(a,b);}
template <class T> void chmin(T& a, const T b){a=min<T>(a,b);}
void YN(bool flg) {cout << ((flg) ? "YES" : "NO") << endl;}
void Yn(bool flg) {cout << ((flg) ? "Yes" : "No") << endl;}
void yn(bool flg) {cout << ((flg) ? "yes" : "no") << endl;}


class Lowest_Common_Ancestor {
public:
	int N, MAX_bit;
	vector<vector<int>> edge;
	vector<int> depth;
	vector<vector<int>> parent;
	vector<vector<int>> child;
	vector<vector<int>> descendant;

	Lowest_Common_Ancestor(int N, int MAX_bit = 20) :N(N), MAX_bit(MAX_bit), edge(N), depth(N, -1), parent(N, vector<int>(MAX_bit)), child(N), descendant(N){
		//do nothing
	}

	//O(1)
	void make_edge(int from, int to) {
		edge[from].push_back(to);
	}

	//O(N)
	void make_depth(int root) {
		queue<int> q;
		depth[root] = 0;
		q.push(root);
		while (q.size()) {
			int from = q.front();
			q.pop();
			for (auto to : edge[from]) {
				if (depth[to] != -1) continue;
				depth[to] = depth[from] + 1;
				q.push(to);
			}
		}
	}

	//O(MAX_bit*N)
	void make_parent() {
		for (int i = 0; i < N; ++i) parent[i][0] = i;
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] > depth[j]) parent[i][0] = j;
		for (int bit = 1; bit < MAX_bit; ++bit) for (int i = 0; i < N; ++i) parent[i][bit] = parent[parent[i][bit - 1]][bit - 1];
	}

	//O(N)
	void make_child() {
		for (int i = 0; i < N; ++i) for (auto j : edge[i]) if (depth[i] < depth[j]) child[i].push_back(j);
	}

	//O(N^2)
	void make_descendant() {
		vector<pair<int,int>> ord(N);
		for (int i = 0; i < N; ++i) ord[i] = {depth[i],i};
		sort(ord.begin(),ord.end(),greater<>());
		for (int i = 0; i < N; ++i) descendant[i].push_back(i);
		for (int i = 0; i < N; ++i) for (auto j : edge[ord[i].second]) if (depth[ord[i].second] < depth[j]) for(auto k: descendant[j]) descendant[ord[i].second].push_back(k);
	}

	//O(MAX_bit*logN)
	int lca(int l, int r) {
		if (depth[l] < depth[r]) swap(l, r);
		int diff = depth[l] - depth[r];
		for (int bit = 0; bit < MAX_bit; ++bit) if (diff & (1 << bit)) l = parent[l][bit];
		int ok = (1 << MAX_bit), ng = -1, md;
		while (ok - ng>1) {
			md = (ok + ng) / 2;
			int x = l, y = r;
			for (int bit = 0; bit < MAX_bit; ++bit) if (md & (1 << bit)) x = parent[x][bit];
			for (int bit = 0; bit < MAX_bit; ++bit) if (md & (1 << bit)) y = parent[y][bit];
			(x == y ? ok : ng) = md;
		}
		for (int bit = 0; bit < MAX_bit; ++bit) if (ok & (1 << bit)) l = parent[l][bit];
		return l;
	}

	void print() {
		cout << " depth { " << depth[0];
		for (int i = 1; i < N; ++i) cout << ", " << depth[i];
		cout << " }" << endl;

		cout << "parent { " << parent[0][0];
		for (int i = 1; i < N; ++i) cout << ", " << parent[i][0];
		cout << " }" << endl;

		cout << " child { " << child[0];
		for (int i = 1; i < N; ++i) cout << ", " << child[i];
		cout << " }" << endl;

		cout << "descen { " << descendant[0];
		for (int i = 1; i < N; ++i) cout << ", " << descendant[i];
		cout << " }" << endl;
	}

};


int main() {
	int N; cin >> N;
	V<ll> A(N);
	REP(i,N) cin >> A[i];
	Lowest_Common_Ancestor tree(N);
	V<int> in(N,0);
	for(int i = 0; i < N - 1; ++i) {
		int a,b; cin >> a >> b;
		a--,b--;
		tree.make_edge(a,b);
		tree.make_edge(b,a);
		in[a]++;
		in[b]++;
	}

	if(N==2){
		YN(A[0]==A[1]);
		return 0;
	}

	int root;
	for(int i = 0; i < N; ++i) {
		if(in[i] > 1) {
			root = i;
			break;
		}
	}

	tree.make_depth(root);
	tree.make_child();

	V<P<int,int>> ord(N);
	for(int i = 0; i < N; ++i) ord[i] = {tree.depth[i],i};
	sort(ALL(ord),greater<>());

	for(int i = 0; i < N; ++i){
		int idx = ord[i].second;
		if(idx == root || tree.child[idx].empty()) continue;
		ll B = 0;
		for(auto e:tree.child[idx]) B += A[e];
		corner(A[idx] > B,"NO");
		if(tree.child[idx].size()==1){
			corner(A[idx]!=B,"NO");
			continue;
		}
		ll x = B - A[idx];
		A[idx] -= x;
		corner(A[idx] < 0,"NO");
		corner(B - 2*x < 0,"NO");
		
		priority_queue<ll> pq;
		for(auto e:tree.child[idx]) pq.push(A[e]);
		if(pq.top() <= B - pq.top()) continue;
		else corner(x > B - pq.top(),"NO");
	}

	ll sum = 0;
	for(auto e:tree.child[root]) sum += A[e];
	corner((2*A[root])!=sum,"NO");
	for(auto e:tree.child[root]) corner(sum - A[e] < A[e],"NO");
	cout << "YES" << endl;
	return 0;
}


Measured memory_bytes: 27648