#include <fstream>
#include <iostream>
#include <vector>

using namespace std;

ifstream f("heavypath.in");
ofstream g("heavypath.out");

vector<int> v[100001], val, lant[100001];
int  greutate[100001], viz[100001], tata_nod[100001] = {-1}, arbint[100001][100001];
int k;

int maxim(int a, int b)
{
    if(a > b)
        return a;
    else
        return b;
}

int actualizare(int nod1, int nod, int st, int dr, int poz, int ce_nod)
{
    if(st == dr)
        arbint[nod1][nod] = val[ce_nod];
    else
    {
        int mij =(st + dr) / 2;
        if(poz > mij)
            actualizare(nod1, 2 * nod + 1, mij+1, dr, poz, ce_nod);
        else
            actualizare(nod1, 2*nod, st, mij, poz, ce_nod);
        arbint[nod1][nod] = maxim(arbint[nod1][2*nod + 1], arbint[nod1][2*nod]);
    }
}
int interogare(int nod, int st, int dr, int a, int b)
{
    if(a <= st && b >= dr)
    {
       return arbint[nod];
    }
    else
    {
        int mij =(st + dr) / 2, MaxLeft = inf, MaxRight = inf;
        if(a <= mij)
            MaxLeft = interogare(2 * nod , st, mij, a, b);
        if(b > mij)
            MaxRight = interogare(2*nod + 1, mij+1, dr, a, b);
        return maxim(MaxRight, MaxLeft);
    }

}

void DFS_ARBORE(int nod, int g)
{
    viz[nod] = 1;
    int i;
    for(i = 0; i < v[nod].size(); i++)
    {
      if(viz[v[nod][i]] == 0)
      {
        g++;
        DFS_ARBORE(v[nod][i], g);
        g--;
      }
    }
    if(v[nod].size() == 1)
    {
      k++;
      greutate[nod] = g;
      lant[k].push_back(nod);
      tata_nod[nod] = k;
    }
    else
    {
      greutate[nod] = g;
      int maxim = 0, care, ce;
      for(i = 0; i < v[nod].size(); i++)
      {
        if(greutate[nod] < greutate[v[nod][i]])
        {
          if(tata_nod[v[nod][i]] != -1)
          {
            if(lant[tata_nod[v[nod][i]]].size() > maxim)
            {
              maxim = tata_nod[v[nod][i]];
              care = tata_nod[v[nod][i]];
              ce = v[nod][i];
            }
          }
        }
      }
      lant[care].push_back(nod);
      tata_nod[nod] = care;
      tata_nod[ce] = -1;
   }
}

void creezArbInt()
{
    for(int i = 1 ; i <= k; i++)
    {
      for(int j = 0; j < lant[i].size(); j++)
      {
        actualizare(k, 1, lant[i].size(), j+1, lant[i][j]);
      }
    }
}


void afisare()
{
  for(int i = 1; i <= k; i++)
  {
    for(int j = 0; j < lant[i].size(); j++)
      g << lant[i][j] << " ";
    g << '\n';
  }
}

int main()
{
    int n, m, a, b, i, t, x, y;
    f >> n >> m;
    val.push_back(-1111);
    for(i = 0 ; i < n; i++)
    {
        f >> a;
        val.push_back(a);
    }
    for(i = 0 ; i < n - 1 ; i++)
    {
      f >> a >> b;
      v[a].push_back(b);
      v[b].push_back(a);
    }
    for(i = 1; i <= n; i++)
    {
      cout << "Nodul: " << i <<": ";
      for(int j = 0; j < v[i].size(); j++)
        cout << v[i][j] << " ";
      cout << '\n';
    }
    DFS_ARBORE(1, 0);
    creezArbInt();
    afisare();
  /*  for(i = 0; i < m; i++)
    {
       f >> t >> x >> y;
       if(t == 0)
       {

       }
       if(t == 1)
       {

       }
    }*/
}