#!/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()

Measured memory_bytes: 211468