#include <bits/stdc++.h>
namespace algo {
template <typename T>
class segment_tree {
private:
std::size_t n;
std::vector<T> seg;
struct accessor {
segment_tree &st;
std::size_t i;
accessor(segment_tree &st, std::size_t i) : st(st), i(i) {}
accessor &operator=(const T &x) {
st.set(i, x);
return *this;
}
accessor &operator+=(const T &x) { return *this = st.at(i) + x; }
accessor &operator-=(const T &x) { return *this = st.at(i) - x; }
operator T() const { return st.at(i); }
friend std::ostream &operator<<(std::ostream &os, const accessor &acc) {
return os << T(acc);
}
};
public:
segment_tree(std::size_t n) : n(n), seg(2 * n) {}
segment_tree(const segment_tree &other) : n(other.n), seg(other.seg) {}
segment_tree() : n(0) {}
segment_tree(std::size_t n, const T &x) : n(n), seg(2 * n) {
for (std::size_t i = n; i < 2 * n; ++i) {
seg[i] = x;
}
for (std::size_t i = n - 1; i > 0; --i) {
seg[i] = seg[2 * i] + seg[2 * i + 1];
}
}
segment_tree(const std::vector<T> &vals) : n(vals.size()), seg(2 * n) {
set(vals);
}
void set(std::size_t i, const T &x) {
for (seg[i += n] = x, i /= 2; i > 0; i /= 2) {
seg[i] = seg[2 * i] + seg[2 * i + 1];
}
}
T query(std::size_t l, std::size_t r) const {
T ans_l = T{}, ans_r = T{};
for (l += n, r += n + 1; l < r; l /= 2, r /= 2) {
if (l & 1)
ans_l = ans_l + seg[l++];
if (r & 1)
ans_r = seg[--r] + ans_r;
}
return ans_l + ans_r;
}
std::size_t size() const { return n; }
const T &at(std::size_t i) const { return seg[n + i]; }
accessor operator[](std::size_t i) { return accessor(*this, i); }
};
template <typename T>
requires std::is_arithmetic_v<T>
struct max_t {
T x;
constexpr max_t() : x(std::numeric_limits<T>::min()) {}
constexpr max_t(const T &x) : x(x) {}
constexpr max_t operator+(const max_t &other) const {
return std::max(x, other.x);
}
constexpr operator T() const { return x; }
constexpr bool operator==(const max_t &other) const { return x == other.x; }
constexpr bool operator!=(const max_t &other) const { return x != other.x; }
};
} // namespace algo
using namespace std;
using namespace algo;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, d;
cin >> n >> d;
vector<vector<int>> adj(n);
for (int i = 1, p; i < n; ++i) {
cin >> p;
adj[p].push_back(i);
}
if (d >= n) {
cout << "1\n";
return 0;
}
vector<int> sz(n);
auto dfs_sz = [&](auto &&self, int u) -> void {
sz[u] = 1;
for (int &i : adj[u]) {
self(self, i);
sz[u] += sz[i];
}
};
dfs_sz(dfs_sz, 0);
auto dfs = [&](auto &&self, int u) -> segment_tree<max_t<int>> {
segment_tree<max_t<int>> dp(sz[u], 0);
for (int &i : adj[u]) {
segment_tree<max_t<int>> _ndp = self(self, i);
segment_tree<max_t<int>> ndp(_ndp.size() + 1, 0);
for (int i = 1; i <= _ndp.size(); ++i) {
ndp[i] = int{_ndp.at(i - 1)};
}
if (ndp.size() > dp.size()) {
swap(dp, ndp);
}
vector<int> qvals;
for (int i = 0; i < ndp.size(); ++i) {
if (max(i + 1, d - i) < dp.size()) {
qvals.push_back(dp.query(max(i + 1, d - i), dp.size() - 1));
} else {
qvals.push_back(0);
}
}
for (int i = 0; i < ndp.size(); ++i) {
if (max(i, d - i) < ndp.size()) {
dp[i] = int{dp.at(i)} + int{ndp.query(max(i, d - i), ndp.size() - 1)};
}
}
for (int i = 0; i < ndp.size(); ++i) {
dp[i] = max(int{dp.at(i)}, int{ndp.at(i)});
}
for (int i = 0; i < ndp.size(); ++i) {
if (max(i + 1, d - i) < dp.size()) {
dp[i] = max(int{dp.at(i)}, qvals[i] + int{ndp.at(i)});
}
}
}
dp[0] = max(int{dp.at(0)}, (d < sz[u] ? int{dp.at(d)} : 0) + 1);
return dp;
};
segment_tree<max_t<int>> dp = dfs(dfs, 0);
cout << dp.query(0, dp.size() - 1) << '\n';
}
