// #pragma GCC optimize("O3,unroll-loops,Ofast")
// #pragma GCC target("avx2")
#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// #define int long long
#define endl '\n'

using namespace std;
using pii = pair<int, int>;
using tup = tuple<int, int, int>;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// template <class T> using ordered_set = tree<T, null_type,
//                          less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

const int inf = 1e9;
const int mod = 1000000007;
const double eps = 1e-9;
const int N = 200005;

void preprocess() {}

vector<int> e[N];
int par[N], dep[N];
int sz[N], mx[N];

void dfs(int u, int p) {
    sz[u] = 1;
    mx[u] = 1;
    par[u] = p;
    for(int v : e[u]) if(v != p) {
        dfs(v, u);
        dep[u]++;
        sz[u] += sz[v];
        mx[u] = max(mx[v] + 1, mx[u]);
    }
}

int dp[N][105];

int que[N];

void solve(int tc) {
    int n, K;
    cin >> n >> K;

    for(int i=1; i<n; i++) {
        int u, v;
        cin >> u >> v;
        e[u].push_back(v);
        e[v].push_back(u);
    }

    dfs(1, -1);
    memset(dp, 0, sizeof dp);

    int p = 0, l = 0;
    for(int i=1; i<=n; i++) if(dep[i] == 0) {
        que[p++] = i;
    }

    while(l < p) {
        int i = que[l++];

        multiset<int> st;
        for(int j : e[i]) if(j - par[i]) 
            st.insert(mx[j]);
        
        for(int k=0; k<=K; k++) {
            int ans = 1;
            for(int j : e[i]) if(j - par[i]) {
                st.erase(st.find(mx[j]));
                ans = max(ans, 1 + dp[j][k]);
                if(st.size() and k) {
                    int mxnow = *st.rbegin();

                    int lo = 0, hi = k-1;

                    int now = 0;
                    while(lo <= hi) {
                        int mid = lo + hi >> 1;

                        int f1 = 1 + dp[j][mid] + min(mxnow, k - mid);
                        int f2 = 1 + dp[j][mid+1] + min(mxnow, k - (mid+1));

                        if(f1 <= f2) lo = mid + 1;
                        else hi = mid - 1;

                        now = max({now, f1, f2});
                    }
                    ans = max(ans, now);
                }
                st.insert(mx[j]);
            }
            dp[i][k] = ans;
        }

        if(par[i] != -1) {
            dep[par[i]]--;
            if(dep[par[i]] == 0) {
                que[p++] = par[i];
            }
        }
    }

    cout << dp[1][K] << endl;
}   

int32_t main() {
    cin.tie(NULL)->sync_with_stdio(false);
    cout.precision(10);

    preprocess();

    int T = 1;
    // cin >> T;

    for (int i = 1; i <= T; i++) {  
        solve(i);
    }

    return 0;
}