#include <bits/stdc++.h>
using namespace std;
int N, K, edgeId[400 + 3][400 + 3], parent[400 + 3];
int dp[400 + 3][400 + 3], bestSz[400 + 3];
vector<int> adj[400 + 3], children[400 + 3];
vector<int> numTaken[400 + 3][400 + 3], answer;
void initializeChildren(int u) {
  for (auto v : adj[u]) {
    if (v != parent[u]) {
      children[u].push_back(v);
      parent[v] = u;
      initializeChildren(v);
    }
  }
}
void DFS(int u) {
  int numChildren = (int)children[u].size();
  int knapsack[2][400 + 3];
  int t = 0;
  knapsack[t][0] = 0;
  for (int sz = 1; sz <= N; sz++) knapsack[t][sz] = 1000;
  for (int i = 1; i <= numChildren; i++) {
    t = 1 - t;
    int v = children[u][i - 1];
    DFS(v);
    for (int sz = 0; sz <= N; sz++) {
      knapsack[t][sz] = 1000;
      int bestCurrentSz;
      for (int currentSz = 0; currentSz <= sz; currentSz++) {
        int prevSz = sz - currentSz;
        int currentCost =
            knapsack[1 - t][prevSz] +
            (currentSz == 0 ? 1 + dp[v][bestSz[v]] : dp[v][currentSz]);
        if (currentCost < knapsack[t][sz]) {
          knapsack[t][sz] = currentCost;
          bestCurrentSz = currentSz;
        }
      }
      numTaken[u][sz + 1].push_back(bestCurrentSz);
    }
  }
  bestSz[u] = 1;
  for (int sz = 1; sz <= N; sz++) {
    dp[u][sz] = knapsack[t][sz - 1];
    if (dp[u][sz] < dp[u][bestSz[u]]) bestSz[u] = sz;
  }
}
void generateSolution(int u, int sz) {
  int numChildren = (int)children[u].size();
  int remainingSz = sz;
  for (int i = numChildren; i >= 1; i--) {
    int v = children[u][i - 1];
    int currentSz = numTaken[u][remainingSz][i - 1];
    if (currentSz == 0) {
      answer.push_back(edgeId[u][v]);
      generateSolution(v, bestSz[v]);
    } else {
      generateSolution(v, currentSz);
    }
    remainingSz -= currentSz;
  }
}
int main() {
  cin >> N >> K;
  for (int i = 1; i < N; i++) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);
    edgeId[u][v] = edgeId[v][u] = i;
  }
  parent[1] = 0;
  initializeChildren(1);
  DFS(1);
  int bestCost = 1000;
  int bestRoot;
  for (int i = 1; i <= N; i++) {
    int cost = dp[i][K] + (i == 1 ? 0 : 1);
    if (cost < bestCost) {
      bestCost = cost;
      bestRoot = i;
    }
  }
  generateSolution(bestRoot, K);
  if (bestRoot != 1) answer.push_back(edgeId[bestRoot][parent[bestRoot]]);
  cout << bestCost << endl;
  for (auto a : answer) cout << a << " ";
  cout << endl;
}
