#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

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

int N, M, t, x, y;
int nL;
int value[100001];
int aint[400004];
int nrNod[100001], lvl[100001], l[100001], lFather[100001], lLvl[100001], lDim[100001], lPos[100001];
vector<int> V[100001], path[100001];
bool used[100001];

void dfs(int nod)
{
    used[nod] = true;
    nrNod[nod] = 1;

    int lastNod = -1, leaf = 1;

    for (vector<int>::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
    {
        if (!used[*it])
        {
            leaf = 0;
            lvl[*it] = lvl[nod] + 1;

            dfs(*it);

            nrNod[nod] += nrNod[*it];

            if (lastNod == -1)
                lastNod = *it;
            else if (nrNod[lastNod] < nrNod[*it])
                lastNod = *it;
        }
    }

    if (leaf)
    {
        ++nL;
        l[nod] = nL;
        lDim[nL] = 1;
        path[nL].push_back(nod);
        return;
    }

    l[nod] = l[lastNod];
    ++lDim[l[lastNod]];
    path[l[lastNod]].push_back(nod);

    for (vector<int>::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
    {
        if (*it == lastNod || lvl[*it] < lvl[nod])
            continue;

        lFather[l[*it]] = nod;
        lLvl[l[*it]] = lvl[nod];
    }
}

void build(int nod, int lt, int rt, int decalaj, int lant)
{
    if (lt == rt)
    {
        aint[nod + decalaj] = value[path[lant][lt - 1]];
        return;
    }

    int mid = (lt + rt) >> 1;

    build(nod * 2, lt, mid, decalaj, lant);
    build(nod * 2 + 1, mid + 1, rt, decalaj, lant);

    aint[nod + decalaj] = max(aint[nod * 2 + decalaj], aint[nod * 2 + 1 + decalaj]);
}

void make_paths()
{
    lvl[1] = 1;
    dfs(1);

    for(int i = 1; i <= nL; ++i)
    {
        reverse(path[i].begin(), path[i].end());

        if(i > 1)
            lPos[i] = lPos[i-1] + lDim[i-1] * 4;

        build(1, 1, lDim[i], lPos[i], i);
    }
}

int main()
{
    fin >> N >> M;
    for (int i = 1; i <= N; ++i)
        fin >> value[i];
    for (int i = 1, nod1, nod2; i <= N - 1; ++i)
    {
        fin >> nod1 >> nod2;
        V[nod1].push_back(nod2);
        V[nod2].push_back(nod1);
    }

    make_paths();
    for (int i = 1; i <= 100; ++i)
        fout << aint[i] << ' ';
    fout << '\n';

    fout << nL << '\n';
    for (int i = 1; i <= nL; ++i)
    {
        for (vector<int>::iterator it = path[i].begin(); it != path[i].end(); ++it)
            fout << *it << ' ';
        fout << '\n';
    }

    fin.close();
    fout.close();
    return 0;
}