Problem p01780 (C++)

Buggy submission (status: Runtime Error):
#include <bits/stdc++.h>
using namespace std;

#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif

typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;

const int inf = 1 << 30;
const long long int infll = 1LL << 58;
const double eps = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (const auto &v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}

struct lca_solver {
  vector<vector<int>> children;
  int root;
  // if root,parent is -1.
  vector<int> parent;
  vector<int> depth;

  vector<vector<int>> parent_pow2;

  lca_solver(vector<vector<int>> children_, int root_)
      : children(children_), root(root_) {
    calc_parent_and_depth();
    calc_parent_pow2();
  };

  int lca(int u, int v) {
    // make sure depth(u) > depth(v).
    if (depth[u] < depth[v])
      swap(u, v);
    for (size_t k = 0; k < parent_pow2.size(); k++) {
      if (((depth[u] - depth[v]) >> k) & 1) {
        u = parent_pow2[k][u];
      }
    }

    if (u == v)
      return u;
    for (int k = (int)parent_pow2.size() - 1; k >= 0; k--) {
      if (parent_pow2[k][u] != parent_pow2[k][v]) {
        u = parent_pow2[k][u];
        v = parent_pow2[k][v];
      }
    }
    return parent_pow2[0][u];
  }

private:
  void calc_parent_and_depth() {
    parent = vector<int>(children.size(), -1);
    depth = vector<int>(children.size(), -1);
    sub_calc_parent_and_depth(root, -1, 0);
  }
  void sub_calc_parent_and_depth(int cur, int par, int dep) {
    parent[cur] = par;
    depth[cur] = dep;
    for (int child : children[cur]) {
      if (child != par) {
        sub_calc_parent_and_depth(child, cur, dep + 1);
      }
    }
  }
  void calc_parent_pow2() {
    // parent_pow2[k][i] = 2^k parent of node i.
    parent_pow2 = vector<vector<int>>(ceil(log(children.size()) / log(2)),
                                      vector<int>(children.size(), -1));
    parent_pow2[0] = parent;
    for (size_t k = 0; k + 1 < parent_pow2.size(); k++) {
      for (size_t v = 0; v < children.size(); v++) {
        if (parent_pow2[k][v] >= 0) {
          parent_pow2[k + 1][v] = parent_pow2[k][parent_pow2[k][v]];
        }
      }
    }
  }
};

void solve() {
  int n;
  cin >> n;
  if (n == 0) {
    cout << 0 << endl;
    return;
  }
  vector<vector<int>> children(n);
  rep(i, 0, n - 1) {
    int p;
    cin >> p;
    --p;
    children[p].emplace_back(i + 1);
  }
  for (auto &x : children)
    sort(x.begin(), x.end());
  lca_solver ls(children, 0);

  queue<int> q;
  int pos = 0;
  ll ans = 0;
  q.push(0);
  while (!q.empty()) {
    const int v = q.front();
    q.pop();
    ans += ls.depth[pos] + ls.depth[v] - ls.depth[ls.lca(pos, v)] * 2;
    pos = v;
    for (const int u : children[v])
      q.push(u);
  }
  cout << ans << endl;
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cout << fixed << setprecision(8);
  solve();
  return 0;
}

Fixed submission:
#include <bits/stdc++.h>
using namespace std;

#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif

typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;

const int inf = 1 << 30;
const long long int infll = 1LL << 58;
const double eps = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (const auto &v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}

struct lca_solver {
  vector<vector<int>> children;
  int root;
  // if root,parent is -1.
  vector<int> parent;
  vector<int> depth;

  vector<vector<int>> parent_pow2;

  lca_solver(vector<vector<int>> children_, int root_)
      : children(children_), root(root_) {
    calc_parent_and_depth();
    calc_parent_pow2();
  };

  int lca(int u, int v) {
    // make sure depth(u) > depth(v).
    if (depth[u] < depth[v])
      swap(u, v);
    for (size_t k = 0; k < parent_pow2.size(); k++) {
      if (((depth[u] - depth[v]) >> k) & 1) {
        u = parent_pow2[k][u];
      }
    }

    if (u == v)
      return u;
    for (int k = (int)parent_pow2.size() - 1; k >= 0; k--) {
      if (parent_pow2[k][u] != parent_pow2[k][v]) {
        u = parent_pow2[k][u];
        v = parent_pow2[k][v];
      }
    }
    return parent_pow2[0][u];
  }

private:
  void calc_parent_and_depth() {
    parent = vector<int>(children.size(), -1);
    depth = vector<int>(children.size(), -1);
    sub_calc_parent_and_depth(root, -1, 0);
  }
  void sub_calc_parent_and_depth(int cur, int par, int dep) {
    parent[cur] = par;
    depth[cur] = dep;
    for (int child : children[cur]) {
      if (child != par) {
        sub_calc_parent_and_depth(child, cur, dep + 1);
      }
    }
  }
  void calc_parent_pow2() {
    // parent_pow2[k][i] = 2^k parent of node i.
    parent_pow2 = vector<vector<int>>(ceil(log(children.size()) / log(2)),
                                      vector<int>(children.size(), -1));
    parent_pow2[0] = parent;
    for (size_t k = 0; k + 1 < parent_pow2.size(); k++) {
      for (size_t v = 0; v < children.size(); v++) {
        if (parent_pow2[k][v] >= 0) {
          parent_pow2[k + 1][v] = parent_pow2[k][parent_pow2[k][v]];
        }
      }
    }
  }
};

void solve() {
  int n;
  cin >> n;
  if (n == 1) {
    cout << 0 << endl;
    return;
  }
  vector<vector<int>> children(n);
  rep(i, 0, n - 1) {
    int p;
    cin >> p;
    --p;
    children[p].emplace_back(i + 1);
  }
  for (auto &x : children)
    sort(x.begin(), x.end());
  lca_solver ls(children, 0);

  queue<int> q;
  int pos = 0;
  ll ans = 0;
  q.push(0);
  while (!q.empty()) {
    const int v = q.front();
    q.pop();
    ans += ls.depth[pos] + ls.depth[v] - ls.depth[ls.lca(pos, v)] * 2;
    pos = v;
    for (const int u : children[v])
      q.push(u);
  }
  cout << ans << endl;
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cout << fixed << setprecision(8);
  solve();
  return 0;
}