output_description: Print N lines. The k-th line, print the length of the longest increasing
  subsequence of the sequence obtained from the shortest path from Vertex 1 to
  Vertex k.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 ... a_N
      u_1 v_1
      u_2 v_2
      :
      u_{N-1} v_{N-1}
attempt: # coding: utf-8
  import sys
  
  stdin = sys.stdin
  ni = lambda: int(ns())
  na = lambda: list(map(int, stdin.readline().split()))
  ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces
  
  
  def dfs(now):
      checked[now] = 1
      sequences[now] += [As[now]]
      ans[now] = LIS(sequences[now])
      for i in tree[now]:
          if checked[i] == 0:
              sequences[i] = [i for i in sequences[now]]
              dfs(i)
  
  
  def BinarySearch(num, nums):
      if len(nums) == 0:
          print("Erorr : list has no element")
          return
      left, right = 0, len(nums)
      while left < right:
          mid = (left + right) // 2
          if num < nums[mid]:
              right = mid
          else:
              left = mid + 1
      return right
  
  
  def LIS(seq):
      LISs = [seq[0]]
      for i in range(1, len(seq)):
          if seq[i] > LISs[-1]:
              LISs.append(seq[i])
          else:
              right = BinarySearch(seq[i], LISs)
              if LISs[right - 1] != seq[i]:
                  LISs[right] = seq[i]
      return len(LISs)
  
  
  tree = []
  checked = []
  As = []
  sequences = []
  ans = []
  
  
  def main():
      global tree, checked, As, sequences, ans
      n = ni()
      As = na()
      tree = [[] for _ in range(n)]  # tree[i] = The children of vertex i
      sequences = [
          [] for _ in range(n)
      ]  # sequences[i] = The sequence of a's values that is shortest path to vertex i
      sequences[0] = [As[0]]
      checked = [0 for _ in range(n)]
      ans = [-1 for _ in range(n)]
      for _ in range(n - 1):
          u, v = na()
          tree[u - 1] += [v - 1]
          tree[v - 1] += [u - 1]
      dfs(0)
      for i in range(n):
          print(ans[i])
      return
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  We have a tree with N vertices, whose i-th edge connects Vertex u_i and Vertex
  v_i. Vertex i has an integer a_i written on it. For every integer k from 1
  through N, solve the following problem:
  
    * We will make a sequence by lining up the integers written on the vertices along the shortest path from Vertex 1 to Vertex k, in the order they appear. Find the length of the longest increasing subsequence of this sequence.
  
  Here, the longest increasing subsequence of a sequence A of length L is the
  subsequence A_{i_1} , A_{i_2} , ... , A_{i_M} with the greatest possible value
  of M such that 1 \leq i_1 < i_2 < ... < i_M \leq L and A_{i_1} < A_{i_2} < ...
  < A_{i_M}.
samples: [{"input": "10\n    1 2 5 3 4 6 7 3 2 4\n    1 2\n    2 3\n    3 4\n    4 5\n    3 6\n    6 7\n    1 8\n    8 9\n    9 10", "output": "1\n    2\n    3\n    3\n    4\n    4\n    5\n    2\n    2\n    3\n    \n\nFor example, the sequence A obtained from the shortest path from Vertex 1 to\nVertex 5 is 1,2,5,3,4. Its longest increasing subsequence is A_1, A_2, A_4,\nA_5, with the length of 4."}]