#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>

using namespace std;

int n, k;

int dfs1(vector< vector<int> >& T)
{
    int odp = n;
    int M = k / 2;
    for (int i = 0; i < n; ++i)
    {
        int x = i;
        vector<int> dl(n);
        vector<bool> odw(n, false);
        dl[x] = 0;
        odw[x] = true;
        stack<int> S;
        vector<int> nry(n, -1);
        for (int j = 0; j < T[x].size(); ++j)
        {
            nry[T[x][j]] = T[x][j];
            S.push(T[x][j]);
            odw[T[x][j]] = true;
            dl[T[x][j]] = 1;
        }
        vector<bool> jest(n, true);
        int il = 0;
        int akt;
        while (!S.empty())
        {
            akt = S.top();
            S.pop();
            if (dl[akt] > M)
            {
                jest[akt] = false;
                ++il;
            }
            for (int j = 0; j < T[akt].size(); ++j)
            {
                if (!odw[T[akt][j]])
                {
                    odw[T[akt][j]] = true;
                    S.push(T[akt][j]);
                    dl[T[akt][j]] = dl[akt] + 1;
                    nry[T[akt][j]] = nry[akt];
                }
            }
        }
        vector<int> maxy(n, -1);
        for (int j = 0; j < n; ++j)
            if (j != x && jest[j])
                maxy[nry[j]] = max(maxy[nry[j]], dl[j]);
        vector<int> m;
        for (int j = 0; j < n; ++j)
            if (maxy[j] != -1)
                m.push_back(maxy[j]);
        sort(m.begin(), m.end());
        reverse(m.begin(), m.end());
        if ((m.size() >= 2 && m[0] == m[1]) || m.size() == 0)
            odp = min(odp, il);
    }
    return odp;
}

int dfs2(vector< vector<int> >& T)
{
    int odp = n;
    int M = k / 2;
    if (k % 2 == 0)
        --M;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < T[i].size(); ++j)
        {
            int x = i, y = T[i][j];
            vector<int> dl(n);
            vector<bool> odw(n, false);
            stack<int> S;
            int akt;
            dl[x] = 0;
            odw[x] = true;
            S.push(x);
            int il = 0;
            int max1 = 0;
            while (!S.empty())
            {
                akt = S.top();
                S.pop();
                if (dl[akt] > M)
                    ++il;
                else
                    max1 = max(max1, dl[akt]);
                for (int j = 0; j < T[akt].size(); ++j)
                {
                    if (!odw[T[akt][j]] && T[akt][j] != y)
                    {
                        odw[T[akt][j]] = true;
                        S.push(T[akt][j]);
                        dl[T[akt][j]] = dl[akt] + 1;
                    }
                }
            }
            dl[y] = 0;
            odw[y] = true;
            S.push(y);
            int max2 = 0;
            while (!S.empty())
            {
                akt = S.top();
                S.pop();
                if (dl[akt] > M)
                    ++il;
                else
                    max2 = max(max2, dl[akt]);
                for (int j = 0; j < T[akt].size(); ++j)
                {
                    if (!odw[T[akt][j]] && T[akt][j] != x)
                    {
                        odw[T[akt][j]] = true;
                        S.push(T[akt][j]);
                        dl[T[akt][j]] = dl[akt] + 1;
                    }
                }
            }
            if (max1 == max2)
                odp = min(odp, il);
        }
    }
    return odp;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin >> n >> k;
    vector< vector<int> > T(n);
    for (int i = 0; i < n - 1; ++i)
    {
        int a, b;
        cin >> a >> b;
        --a;
        --b;
        T[a].push_back(b);
        T[b].push_back(a);
    }
    cout << min(dfs1(T), dfs2(T));
    return 0;
}


Measured memory_bytes: 384