#include <bits/stdc++.h>
using namespace std;
int N, K, dp[400 + 3][400 + 3], bestSz[400 + 3];
int edgeId[400 + 3][400 + 3], parent[400 + 3];
vector<int> adj[400 + 3], children[400 + 3];
vector<int> answerIndices;
vector<int> taken[400 + 3][400 + 3];
void preprocess(int u, int prv) {
  for (auto v : adj[u]) {
    if (v != prv) {
      children[u].push_back(v);
      parent[v] = u;
      preprocess(v, u);
    }
  }
}
void DFS(int u, int prv) {
  int numChildren = (int)children[u].size();
  int dp1[2][400 + 3];
  dp1[0][0] = 0;
  for (int sz = 1; sz <= N; sz++) dp1[0][sz] = 1000;
  int t = 0;
  for (int i = 1; i <= numChildren; i++) {
    t = 1 - t;
    int child = children[u][i - 1];
    if (child == prv) continue;
    DFS(child, u);
    for (int sz = 0; sz <= N; sz++) {
      dp1[t][sz] = 1000;
      int bestCurrentSz;
      for (int prvSz = 0; prvSz <= sz; prvSz++) {
        int currentSz = sz - prvSz;
        int currentCost = (currentSz == 0 ? 1 + dp[child][bestSz[child]]
                                          : dp[child][currentSz]);
        if (dp1[1 - t][prvSz] + currentCost < dp1[t][sz]) {
          dp1[t][sz] = dp1[1 - t][prvSz] + currentCost;
          bestCurrentSz = currentSz;
        }
      }
      taken[u][sz + 1].push_back(bestCurrentSz);
    }
  }
  bestSz[u] = 1;
  for (int sz = 1; sz <= N; sz++) {
    dp[u][sz] = dp1[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();
  for (int i = numChildren; i >= 1; i--) {
    int child = children[u][i - 1];
    if (taken[u][sz][i - 1] == 0) {
      answerIndices.push_back(edgeId[u][child]);
      generateSolution(child, bestSz[child]);
    } else
      generateSolution(child, taken[u][sz][i - 1]);
    sz -= taken[u][sz][i - 1];
  }
}
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;
  }
  preprocess(1, 0);
  DFS(1, 0);
  int answer = 1000;
  int bestRoot;
  for (int i = 1; i <= N; i++) {
    int par = (i == 1 ? 0 : 1);
    if (par + dp[i][K] < answer) {
      answer = par + dp[i][K];
      bestRoot = i;
    }
  }
  generateSolution(bestRoot, K);
  if (bestRoot != 1)
    answerIndices.push_back(edgeId[bestRoot][parent[bestRoot]]);
  cout << answer << endl;
  for (auto i : answerIndices) cout << i << " ";
  cout << endl;
}
