#include <iostream>
#include <vector>
#include <cstring>
#include <set>
/*
 centroid decomposition to solve Cat in Tree problem
 */

using namespace std;
#define INF (1e9)
const int MX = 200005;  // Adjust the maximum number of nodes as needed

vector<int> adj[MX];
bool visited[MX];
int subtreeSize[MX];
int min_dist[MX];
vector<vector<pair<int, int>>> ancestors;
int N, D;
int dfs_depth;
set<pair<int,int>> nodes;
int ans;

int dfs(int node, int parent, int depth = 1) {
    nodes.insert({-depth,node});
    subtreeSize[node] = 1;
    dfs_depth = max(dfs_depth, depth); //dfs_depth should be set zero before running a dfs
    for (int child : adj[node]) {
        if (child != parent && !visited[child]) {
            subtreeSize[node] += dfs(child, node, depth+1);
        }
    }
    return subtreeSize[node];
}

int find_cent(int node, int parent, int treesize) {
    for (int child : adj[node]) {
        if (child != parent && !visited[child]) {
            if (subtreeSize[child] *2 >= treesize)
                return find_cent(child, node, treesize);
        }
    }
    return node;
}

void get_dists(int node, int centroid, int parent = -1, int cur_dist = 1) {
    for (int child : adj[node]) {
        if (child == parent || visited[child]) { continue; }
        cur_dist++;
        get_dists(child, centroid, node, cur_dist);
        cur_dist--;
    }
    ancestors[node].push_back({centroid, cur_dist});
}

void decompose(int centroid) {
    // do your work at the centroid
    
    for (int child : adj[centroid]) {
        if (visited[child]) { continue; }
        get_dists(child, centroid, centroid);
    }
    
    // Mark the centroid and its subtree as visited
    visited[centroid] = true;
    for (int child : adj[centroid]) {
        if (!visited[child]) {
            // Recursively decompose the subtrees
            dfs_depth = 0;
            int subtreeSize = dfs(child, centroid,1);
            int childCentroid = find_cent(child, centroid, subtreeSize);
            decompose(childCentroid);
        }
    }
}

int centralDecomposition(int root) {
    int treeSize = dfs(root, -1);
    int centroid = find_cent(root, -1, treeSize);
    // Process the centroid and its subtree
    decompose(centroid);
    return treeSize;
}

/**
 * Paint `node` red by updating all of its ancestors' minimal distances
 * to a red node
 */
void paintRed (int node) {
    for (auto &[ancestor, dist] : ancestors[node]) {
        min_dist[ancestor] = min(min_dist[ancestor], dist);
    }
    min_dist[node] = 0;
}

int query(int node) {
    int ans = min_dist[node];
    for (auto &[ancestor, dist] : ancestors[node]) {
        if (!dist) { continue; }
        ans = min(ans, dist + min_dist[ancestor]);
    }
    return ans;
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> N >> D;
    for (int i = 1; i <= N - 1; ++i) {
        int u;
        cin >> u;
        adj[i].push_back(u);
        adj[u].push_back(i);
    }
    memset(min_dist, 0x3f, sizeof min_dist);
    ancestors.assign(N+1, vector<pair<int, int>>());
    centralDecomposition(1);
    auto cur = (*nodes.begin()).second;
    ans ++ ;
    paintRed(cur);
    nodes.erase(nodes.begin());
    for (auto it = nodes.begin(); it != nodes.end(); it++) {
        auto next = *it;
        if (query(next.second) >= D) {
            paintRed(next.second);
            ans++;
  
        }
    }
    cout << ans ;
    return 0;
}