#include <fstream>
#include <list>
#include <bitset>
#include <deque>
#include <vector>

using namespace std;

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

const int maxV = 1000;

list <int> adjList[1 + maxV];

vector <int> degree;
vector <int> dist;

bitset <1 + maxV> seen;
bitset <1 + maxV> marked;
bitset <1 + maxV> solution;

int V, E, K;

void resizeVectors() {

	degree.resize(V + 1);
	dist.resize(V + 1);
}

inline int check(const int &currDist) {

	deque <int> Queue;

	marked.reset();
	seen.reset();

	for (int node = 1; node <= V; ++node)
		if (degree[node] == 1) {

			Queue.push_back(node);
			dist[node] = 0;
			seen[node] = true;
		}

	int usedNodes = 0;
	while (!Queue.empty()) {

		int node = Queue.front();
		Queue.pop_front();

		for (const int &nextNode : adjList[node])
			if (!seen[nextNode]) {

				if (dist[node] == currDist)
					dist[nextNode] = 0;
				else
					dist[nextNode] = dist[node] + 1;

				Queue.push_back(nextNode);
				seen[nextNode] = true;

				if (dist[nextNode] == currDist) {

					++usedNodes;
					marked[nextNode] = true;
				}
			}
	}

	return usedNodes;
}

int main() {

	fin >> V >> K;
	E = V - 1;

	resizeVectors();
	degree.resize(1 + V, 0);

	for (; E; --E) {

		int from, to;
		fin >> from >> to;

		adjList[from].push_back(to);
		adjList[to].push_back(from);

		++degree[from]; ++degree[to];
	}

	int ans = 0, usedNodes = 0;
	int low = 1, high = V - 1;

	while (low <= high) {

		int mid = (low + high) / 2;
		int checker = check(mid);

		if (checker <= K) {

			ans = mid;
			usedNodes = checker;
			high = mid - 1;

			for (int node = 1; node <= V; ++node)
				solution[node] = marked[node];
		}
		else low = mid + 1;
	}

	fout << ans << '\n';
	
	usedNodes = K - usedNodes;
	for (int node = 1; usedNodes; ++node)
		if (!solution[node]) {

			solution[node] = true;
			--usedNodes;
		}
	
	for (int node = 1; node <= V; ++node)
		if (solution[node])
			fout << node << ' ';
}