孩子破防了，从 set 启发式合并换成 pbds priority_queue，调了好几种 heap 标签，指令集和 fio 快读全加上了，最后 TLE#43，难过

参考：

binary_heap_tag：TLE#32 被菊花卡

pairing_heap_tag：TLE#9 明明应该是最快的一个，不知道为啥

binomial_heap_tag：TLE#43

复杂度应该是 nlogn 吧，，

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#define pq __gnu_pbds::priority_queue
#define pqg pq<int, greater<int>, __gnu_pbds::binomial_heap_tag>
 
using namespace std;
 
struct ios {
    inline char read() {
        static const int inlen = 1 << 18 | 1;
        static char buf[inlen], *s, *t;
        return (s == t) && (t = (s = buf) + fread(buf, 1, inlen, stdin)), s == t ? -1 : *s++;
    }
    template<typename T> inline ios& operator>> (T &x) {
        static char c11, boo;
        for (c11 = read(), boo = 0; !isdigit(c11); c11 = read()) {
            if (c11 == -1) return *this;
            boo |= c11 == '-';
        }
        for (x = 0; isdigit(c11); c11 = read()) x = x * 10 + (c11 ^ '0');
        boo && (x = -x);
        return *this;
    }
} fin;
 
struct exios {
    template<typename _CharT, typename _Traits = char_traits<_CharT>>
    struct typ {
        typedef basic_ostream<_CharT, _Traits>& (* end) (basic_ostream<_CharT, _Traits>&);
    };
 
    template<typename T> friend exios &operator<<(exios &out, T num) {
        if (num < 0) putchar('-'), num = -num;
        if (num >= 10) out << num / 10;
        putchar(num % 10 + '0');
        return out;
    }
 
    friend exios &operator<<(exios &out, const char * s) { printf("%s", s); return out; }
    friend exios &operator<<(exios &out, string s) { cout << s; return out; }
    friend exios &operator<<(exios &out, typ<char>::end e) { puts(""); return out; }
} fout;
 
const int maxn = 1e6 + 10;
 
int n, k, rt;
vector<int> g[maxn];
int deg[maxn];
int dep[maxn];
pqg p[maxn];
 
void dfs(int u, int fa) {
	dep[u] = dep[fa] + 1;
	for (int v : g[u]) {
		if (v == fa) continue;
		dfs(v, u);
	}
}
 
void solve(int u, int fa) {
	if (deg[u] == 1) return;
	for (int v : g[u]) {
		if (v == fa) continue;
		solve(v, u);
	}
	pqg res = pqg();
	for (int v : g[u]) {
		if (v == fa) continue;
		res.join(p[v]);
	}
	int x, y = res.top();
	while (res.size() >= 2) {
		x = res.top(), res.pop();
		y = res.top();
		if (x + y - dep[u] * 2 > k) p[u].push(x);
	}
	p[u].push(y);
}
 
signed main() {
	fin >> n >> k;
	for (int i = 1, u, v; i < n; i++) {
		fin >> u >> v;
		g[u].push_back(v), g[v].push_back(u);
		deg[u]++, deg[v]++;
	}
	for (int i = 1; i <= n; i++) if (deg[i] != 1) rt = i, i = n + 1;
	dep[0] = -1;
	dfs(rt, 0);
	for (int i = 1; i <= n; i++) if (deg[i] == 1) p[i].push(dep[i]);
	solve(rt, 0);
	fout << p[rt].size() << endl;
	return 0;
}