#include <bits/stdc++.h>
#define DEF 1010
#define INF 1 << 29

using namespace std;

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

vector < int > L[DEF], Sol;

int n, m, k;

int Dist[DEF], T[DEF], nrFii[DEF], Fr[DEF];

deque < int > Q;

bitset < DEF > Viz;

void dfs (int nod) {
    Viz[nod] = 1;

    for (auto it : L[nod]) {
        if (Viz[it] == 0) {
            T[it] = nod;
            dfs (it);
        }
    }
}

bool check (int maxDist) {
    nrFii[1] = L[1].size ();
    for (int i = 2; i <= n; ++ i) {
        Dist[i] = INF;
        if (L[i].size () == 1) {
            Q.push_back (i);
            Dist[i] = maxDist;
        }
        nrFii[i] = L[i].size () - 1;
    }

    Sol.clear ();

    int nr = k;
    for (auto it : Q) {
        Dist[it] = maxDist;
    }

    while (!Q.empty ()) {
        int nod = Q.front ();
        Q.pop_front ();

        if (L[nod].size () != 1 || nod == 1) {

            for (auto it : L[nod]) {
                if (it != T[nod]) {
                    Dist[nod] = min (Dist[nod], Dist[it] - 1);
                }
            }

            if (Dist[nod] == 0) {
                Dist[nod] = 2 * maxDist + 1;
                -- nr;
                Sol.push_back (nod);
                if (nr < 0)
                    break;
            }

        }

        -- nrFii[T[nod]];
        if (nrFii[T[nod]] == 0)
            Q.push_back (T[nod]);
    }

    if (Dist[1] <= maxDist) {
        -- nr;
        Sol.push_back (1);
    }
    return (nr >= 0);
}

int main () {

    fin >> n >> k;

    for (int i = 1; i <= n - 1; ++ i) {
        int x, y;
        fin >> x >> y;
        L[x].push_back (y);
        L[y].push_back (x);
    }

    dfs (1);


    int st = 1, dr = n, mid = (st + dr) / 2;
    while (st <= dr) {
        if (check (mid)) {
            dr = mid - 1;
        }
        else {
            st = mid + 1;
        }
        mid = (st + dr) / 2;
    }

    fout << st << "\n";

    check (st);

    for (auto it : Sol) {
        Fr[it] = 1;
    }

    for (int i = 1; i <= n; ++ i) {
        if (Fr[i] == 0 and Sol.size () < k) {
            Sol.push_back (i);
        }
    }

    sort (Sol.begin (), Sol.end ());

    for (auto it : Sol)
        fout << it << ' ';

    return 0;
}