#include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <algorithm>
#include <utility>
#include <cmath>
#include <map>
#include <deque>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <limits.h>
using namespace std;

ifstream fin("cerere.in");
ofstream fout("cerere.out");

const int MAX_SIZE = 100000;

vector<int> tree[MAX_SIZE + 1], reverseTree[MAX_SIZE + 1];
int ancestorDegree[MAX_SIZE + 1], noHands[MAX_SIZE + 1], level[MAX_SIZE + 1];

void findNoHands(int cur, int curLevel) { // sa ia ramurile pe rand?
    level[curLevel] = cur; // setam nivelul curent;
    int curAncestorDegree = ancestorDegree[cur];
    if (curAncestorDegree == 0) {
        noHands[cur] = 0;
    } else {
        noHands[cur] = noHands[level[curLevel - curAncestorDegree]] + 1;
    }
    for (int next : tree[cur]) {
        findNoHands(next, curLevel + 1);
    }
}

int main() {
    int noMonkeys;
    fin >> noMonkeys;
    for (int i = 1; i <= noMonkeys; ++i) {
        fin >> ancestorDegree[i];
        noHands[i] = -1;
    }
    for (int i = 1; i < noMonkeys; ++i) {
        int parent, child;
        fin >> parent >> child;
        tree[parent].push_back(child);
        reverseTree[child].push_back(parent);
    }
    int root = -1;
    for (int i = 1; i <= noMonkeys; ++i) {
        if (reverseTree[i].size() == 0) {
            root = i;
            break;
        }
    }
    findNoHands(root, 1);
    for (int i = 1; i <= noMonkeys; ++i) {
        fout << noHands[i] << " ";
    }
}

/*
 
 La problema: "https://www.infoarena.ro/problema/cerere"
 Am facut o implementare de 50 de puncte in felul urmator:
 - am creat 2 grafuri: unul care merge normal, de la root spre frunze, iar celalalt care merge de la frunze spre root.
 - am aflat root-ul, dupa care am apelat o functie care porneste de la root si in care parcurg normal graful:
 - atunci cand dau de un punct nou, apelez functia "reverse", care merge cu "k" unitati (conform input-ului) spre stramosul sau. Costul acestui punct curent va fi egal cu costul stramosului de grad "k" plus 1 unitate.
 De mentionat e faptul ca unele puncte cu grad k = 0 din enunt, vor ramane la costul de 0.
 
 La final afisam costurile pentru fiecare punct in parte, acesta fiind si raspunsul.
 
 Primesc la restul de teste TLE, din cauza ca eu pentru fiecare punct ma deplasez "invers" cu "k" unitati.
 
 Trebuie sa gasesc un mod in care sa aflu cumva stramosii fiecarui punct fara sa fie nevoie sa fac aceasta parcurgere inversa. Adica sa parcurg o singura data graful, in O(n), avand in vedere limita de timp foarte mica a problemei.
 
 
 
 */