#include <bits/stdc++.h>
using namespace std;

const int DIM = 1e3 + 5;

int dp[DIM];
bitset<DIM> oki;
vector<int> edg[DIM], stk;

void dfs(int x, int f, int val)
{
    int mnm = numeric_limits<int> :: max();
    
    for (int y : edg[x]) {
        if (y == f)
            continue;
        
        dfs(y, x, val);
        dp[x] = max(dp[x], dp[y] + 1);
        mnm = min(mnm, dp[y] + 1);
    }
    
    if (dp[x] == val) {
        dp[x] = (val + 1) * (-1);
        stk.push_back(x);
    }
    
    if (mnm < 0 || (mnm + 1) * (-1) >= dp[x])
        dp[x] = mnm;
    if (x == 1 && dp[x] >= 0)
        stk.push_back(x);
    
    return;
}

bool solve(int val, int n, int k)
{
    stk.clear();
    fill(dp + 1, dp + n + 1, 0);
    
    dfs(1, 0, val);
    return stk.size() <= k;
}

int main(void)
{
    freopen("salvare.in" , "r", stdin );
    freopen("salvare.out", "w", stdout);
    
    int n, k;
    scanf("%d %d", &n, &k);
    
    for (int i = 1; i < n; ++i) {
        int x, y;
        scanf("%d %d", &x, &y);
        
        edg[x].push_back(y);
        edg[y].push_back(x);
    }
    
    int pos = -1;
    for (int le = 0, ri = n; le <= ri; ) {
        int md = (le + ri) >> 1;
        
        if (solve(md, n, k))
            pos = md, ri = md - 1;
        else
            le = md + 1;
    }
    
    solve(pos, n, k);
    for (int x : stk)
        oki[x] = true;
    
    for (int i = 1; i <= n; ++i)
        if (k != stk.size() && !oki[i])
            stk.push_back(i);
    sort(stk.begin(), stk.end());
    
    printf("%d\n", pos);
    for (int x : stk)
        printf("%d ", x);
    
    
    return 0;
}