#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<int> G[n];
    for (int i = 0; i < n - 1; ++i) {
        int p;
        cin >> p;
        --p;
        G[p].push_back(i + 1);
    }
    vector<int> f(n, 1);
    vector<int> sz(n, 1);
    function<void(int)> dfs = [&](int u) {
        if (G[u].size() == 0) {
            f[u] = 1;
            sz[u] = 1;
            return;
        }
        vector<pair<int, int>> odd;
        vector<int> even;
        for (int i = 0; i < G[u].size(); ++i) {
            int v = G[u][i];
            dfs(v);
            sz[u] += sz[v];
            if (sz[v] % 2 == 0) {
                if (sz[v] - f[v] >= f[v]) {
                    f[u] += f[v];
                } else {
                    even.push_back(v);
                }
            } else {
                odd.push_back(make_pair(sz[v] - f[v] - f[v], v));
            }
        }
        sort(odd.begin(), odd.end());
        reverse(odd.begin(), odd.end());
        for (int i = 0; i < odd.size(); ++i) {
            int v = odd[i].second;
            if (i % 2 == 0) {
                f[u] += f[v];
            } else {
                f[u] += sz[v] - f[v];
            }
        }
        for (int i = 0; i < even.size(); ++i) {
            int v = even[i];
            if (odd.size() % 2 == 1) {
                f[u] += sz[v] - f[v];
            } else {
                f[u] += f[v];
            }
        }
    };
    dfs(0);
    cout << f[0] << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
using ll = long long;
using pii = pair<int,int>;

int main(){
  int n; cin >> n;
  vector<int> p(n);
  vector<vector<int>> tree(n);

  rep(i,n-1){
    int p; cin >> p; p--;
    tree[p].push_back(i+1);
  }

  /*
  頂点vを根とした木で考えたときの chokudaiさんのスコア - kenshoさんのスコア = f(v) とする
  頂点vを根とした木の大きさ = g(v)

  頂点vからどの子に移動するのが最適か
  vの子供uにおいて

  g(u) %2 == 1
  => -f(u)して、手番が逆になる

  else
  => -f(u)して、もう一回動かせる

  から、 f(u)が小さい順に選ぶ？

  1. f(u)<0 かつ、g(u)%2 == 0
  2. g(u)%2 == 1 のもののf(u)
    3. (f(u)>=0 かつ、g(u)%2 == 0)の合計 の昇順
  //*/

  vector<int> f(n, 1), g(n, 1);

  auto dfs = [&](auto self, int v=0) -> void{
    vector<int> p;
    int sum = 0;
    for(auto&&u : tree[v]){
      self(self, u);
      g[v] += g[u];

      if(g[u]%2 == 0){
        if(f[u] < 0) f[v] += f[u];
        else sum += f[u];
      }else{
        p.push_back(f[u]);
      }
    }
    sort(p.begin(), p.end());
    int turn = -1;
    for(auto&&x : p){
      f[v] -= x * turn;
      turn *= -1;
    }
    f[v] -= sum * turn;
  };

  dfs(dfs);

  /*
  a + b = n
  a - b = f[0]
  a = (n + f[0])/2
  //*/

  cout << (n + f[0])/2 << endl;
}