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

using namespace std;

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

const int N = 1001;

int n,k,ND[N],L[11][N],SOL,log[N];
vector<int> G[N],V,SP;
bool UZ[N];

void READ ()
{

    in>>n>>k;

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

}

int T (int nod,int D)
{
    for( int i=log[n] ; i >= 0 ; --i )
        if( (1<<i) <= D )
        {
            D-=(1<<i);
            nod=L[i][nod];
        }
    return nod;
}

void DF (int nod,int D)
{

    if( !D )
        return;

    V[nod]=D;

    for( vector<int>::iterator it=G[nod].begin() ; it < G[nod].end() ; ++it )
        if( D > V[*it]+1 )
            DF ( *it , D-1 );

}

bool OK (int D)
{

    V.assign(n+1,0);
    vector<int> S;

    for( int i=1 ; i <= n ; ++i )
    {

        if( !V[ND[i]] )
        {
            int LC=T(ND[i],D);
            S.push_back(LC);
            DF(LC,D+1);
        }

        if( S.size() > k )
            return 0;

    }

    SP=S;

    return 1;

}

void SEARCH (int ft,int bk)
{

    if( ft == bk )
    {
        if( ft < SOL && OK(ft) )
            SOL=ft;
        return;
    }

    int mid=(ft+bk)>>1;

    if( OK(mid) )
    {
        SOL=mid;
        SEARCH ( ft , mid );
        return ;
    }

    SEARCH ( mid+1  , bk );


}

void SOLVE ()
{

    queue<int> Q;
    int m=n;
    L[0][1]=1;
    for( Q.push(1) ; Q.size() ; Q.pop() )
    {
        int nod=Q.front();
        ND[m]=nod;
        --m;
        for( vector<int>::iterator it=G[nod].begin() ; it < G[nod].end() ; ++it )
            if( !L[0][*it] )
            {
                L[0][*it]=nod;
                Q.push(*it);
            }
    }

    for( int i=2 ; i <= n ; ++i )
        log[i]=log[i>>1]+1;

    for( int i=1 ; i <= log[n] ; ++i )
        for( int j=1 ; j <=n ; ++j )
            L[i][j]=L[i-1][L[i-1][j]];

    SEARCH ( 0 , n/k+1 );

    for( vector<int>::iterator it=SP.begin() ; it < SP.end() ; ++it )
        UZ[*it]=1;

    k-=SP.size();

    for( int i=1 ; i <= n && k ; ++i  )
        if( !UZ[i] )
        {
            SP.push_back(i);
            --k;
        }
    sort( SP.begin() , SP.end() );

}

void PRINT ()
{

    out<<SOL<<'\n';

    for( vector<int>::iterator it=SP.begin() ; it < SP.end() ; ++it )
        out<<*it<<' ';

}

int main ()
{

    READ ();
    SOLVE ();
    PRINT ();

    return 0;

}