output_description: If it is possible to remove all the stones from the vertices, print `YES`.
  Otherwise, print `NO`.
  
  * * *
input_description: 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}
attempt: import sys
  
  sys.setrecursionlimit(10**5 + 5)
  
  
  def dfs(v, p, aaa):
      if len(links[v]) == 1:
          return aaa[v]
  
      children = []
      for u in links[v]:
          if u == p:
              continue
          result = dfs(u, v, aaa)
          if result == -1:
              return -1
          children.append(result)
  
      if len(children) == 1:
          if aaa[v] != children[0]:
              return -1
          return children[0]
  
      c_sum = sum(children)
      c_max = max(children)
      o_max = c_sum - c_max
  
      if o_max >= c_max:
          max_pairs = c_sum // 2
      else:
          max_pairs = o_max
      min_remain = c_sum - max_pairs
      if not min_remain <= aaa[v] <= c_sum:
          return -1
  
      return aaa[v] * 2 - c_sum
  
  
  def solve(n, aaa, links):
      # 葉でない頂点探し
      s = 0
      while len(links[s]) == 1:
          s += 1
  
      return dfs(s, -1, aaa) == 0
  
  
  n = int(input())
  aaa = list(map(int, input().split()))
  links = [set() for _ in range(n)]
  for line in sys.stdin:
      a, b = map(int, line.split())
      a -= 1
      b -= 1
      links[a].add(b)
      links[b].add(a)
  
  print("YES" if solve(n, aaa, links) else "NO")
  
problem_description: 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.
samples: [{"input": "5\n    1 2 1 1 2\n    2 4\n    5 2\n    3 2\n    1 3", "output": "YES\n    \n\nAll the stones can be removed, as follows:\n\n  * Select vertices 4 and 5. Then, there is one stone remaining on each vertex except 4.\n  * Select vertices 1 and 5. Then, there is no stone on any vertex.\n\n* * *"}, {"input": "3\n    1 2 1\n    1 2\n    2 3", "output": "NO\n    \n\n* * *"}, {"input": "6\n    3 2 2 2 2 2\n    1 2\n    2 3\n    1 4\n    1 5\n    4 6", "output": "YES"}]