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: #!/usr/bin/env python
  import os
  import sys
  from io import BytesIO, IOBase
  
  
  def lb(a, x):
      l, r = 0, len(a)
      while r - l > 1:
          m = (l + r) // 2
          if a[m] < x:
              l = m
          else:
              r = m
      return r
  
  
  class FenwickTree:
      def __init__(self, n):
          """transform list into BIT"""
          self.bit = [[0] for _ in range(n)]
  
      def update(self, idx, fl, x):
          """updates bit[idx] += x"""
          while idx < len(self.bit):
              if fl:
                  self.bit[idx].append(max(x, self.bit[idx][-1]))
              else:
                  self.bit[idx].pop()
              idx |= idx + 1
  
      def query(self, end):
          """calc sum(bit[:end])"""
          x = 0
          while end:
              x = max(x, self.bit[end - 1][-1])
              end &= end - 1
          return x
  
  
  def dfs(graph, start, a):
      n = len(graph)
  
      dp = [0] * n
      visited, finished = [False] * n, [False] * n
  
      tree = FenwickTree(n + 5)
      b = []
  
      stack = [start]
      while stack:
          start = stack[-1]
  
          # push unvisited children into stack
          if not visited[start]:
  
              tree.update(a[start], True, 1 + tree.query(a[start]))
              dp[start] = tree.query(n + 1)
              b += [a[start]]
              # print(start,b,dp[start])
  
              visited[start] = True
              for child in graph[start]:
                  if not visited[child]:
                      stack.append(child)
  
          else:
              stack.pop()
              b.pop()
              # pop start.
              tree.update(a[start], False, 0)
              finished[start] = True
  
      return dp
  
  
  def main():
      n = int(input())
      a = [int(x) for x in input().split()]
      b = [x for x in a]
      b.append(-1)
      b.append(10**9 + 1)
      b.sort()
      for i in range(len(a)):
          a[i] = lb(b, a[i])
      e = [[] for _ in range(n)]
      # print(e)
      for _ in range(n - 1):
          u, v = map(int, input().split())
          e[u - 1].append(v - 1)
          e[v - 1].append(u - 1)
  
      # print(e)
      print(*dfs(e, 0, a))
  
  
  # region fastio
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  # endregion
  
  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."}]