//clumsy code for Vincent's dynprog idea
#include <vector>
#include <cstdio>
#include <cstdlib> 
#include <cmath>
#include <cstring>
#include <iostream>
using namespace std;

#define NMAX 100000

int** maxsum;

struct Edge {int v1, v2;};
typedef struct Edge Edge;
vector<Edge> adj[NMAX];
vector<Edge> children[NMAX];
int q[NMAX];
int seen[NMAX];
int N,P;

void solve(int k) {
    for (int i = 0; i<N; ++i)
        memset(maxsum[i], 0, (k+1)*sizeof(int));
    for (int i = N-1; i>=0; i--) {
        int crt = q[i];
        for (int b = 0; b<=k; ++b) {
            maxsum[crt][b] = 0;
            if (2*b<=k) { //cas 1
                for (Edge childedge: children[crt]) {
                    int child = childedge.v1+childedge.v2-crt;
                    int maxperchild = 0;
                    for (int w = 0; w<=b; ++w) 
                        if (maxsum[child][b-w]+w > maxperchild)
                            maxperchild = maxsum[child][b-w]+w;
                    maxsum[crt][b]+=maxperchild;
                }
            } else {
                //start from here
                if (b>=1) maxsum[crt][b]=maxsum[crt][b-1];
                for (int w = k/2+1; w<=b; ++w) { // for each possible weight w;
                    for (Edge childedge: children[crt]) { //for each "main child"
                        
                        int thissum = 0;
                        int mainchild = childedge.v1+childedge.v2-crt;
                        for (Edge childedge2: children[crt]) {
                            int child = childedge2.v1+childedge2.v2-crt;
                            int maxperchild = 0;
                            int maxquant = (child == mainchild)? w:k-w;
                            for (int wi = 0; wi<=maxquant; wi++)
                                if (maxsum[child][maxquant-wi] + wi > maxperchild) 
                                    maxperchild = maxsum[child][maxquant-wi] + wi;
                            thissum +=maxperchild;
                        }
                        if (thissum>maxsum[crt][b])
                            maxsum[crt][b] = thissum;
                }
            }
          }
        }
     }
     //phew      
}
    

int main() {
  int x, y;
  scanf("%d %d", &N, &P);
  maxsum = new int*[N];
  for (int i = 0; i<N; ++i)
      maxsum[i] = new int[P];


  for(int i = 0; i < N-1; i++) {
    scanf("%d %d", &x, &y);
    Edge e;
    e.v1 = x;
    e.v2 = y,
    adj[x].push_back(e);
    adj[y].push_back(e);
  }
  int root = 0;
  while (adj[root].size() == 1) ++root;
  q[0] = root;
  memset(seen,0, sizeof(int)*N);
  int first = 0, last = 0;
  seen[root] = 1;
  while (first<=last) {
    int crt = q[first];
    for (Edge e: adj[crt]) {
        int other = e.v1+e.v2-crt;
        if (seen[other]) continue;
         last++;
        q[last] = other;
        children[crt].push_back(e);
        seen[other]=1;
       
    }
    first ++;
  }

  int k = 1;
  while (true) {
    solve(k);
    int max = maxsum[root][k];
    if (max >= P) break;
    k*=2;
  }

  //now do dichotomy:
  first = k/2;
  last = k;
  while (first<=last) {
     int mid = (first+last)/2;
     solve(mid);
     int max = maxsum[root][mid];;
     if (max<P)
        first = mid+1;
     else 
        last = mid-1;
  }
  cout<<first<<endl;

  for (int i = 0; i<N; ++i)
      delete[] maxsum[i];
  delete[] maxsum;
        
  return 0;
}