Problem p01288 (C++) — buggy submission, verdict: Runtime Error

#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;

//// < "D:\\D_Download\\Visual Studio
///2015\\Projects\\programing_contest_c++\\Debug\\a.txt"

//

#define Seg_Max_N (1 << 18)
// update(l,r,v) := [l,r]?????????????????????v???????§?????¶????.
// k,a,b????£????

struct NODE {
  int sum; //??´??°????????????.
           //?????????????????§??????????????????????????¨????????????????????????????????????.
  int lazy; //?????¶???????????????????????????????????????
  NODE() { sum = lazy = 0; }
};

NODE seg[2 * Seg_Max_N];

// inline??????????????¨??§???????????¨????????????!(??????)
inline void lazy_evaluate_node(int k, int a, int b) {
  seg[k].sum = max(seg[k].sum, seg[k].lazy);
  if (k <
      Seg_Max_N) { // 2*k(???????????????) < 2*N (???????????°)
                   // ?????????????????§.
                   // ???????????????????????????????????¬???????????¨??????.
    seg[2 * k].lazy =
        max(seg[2 * k].lazy,
            seg[k].lazy); //?¬???????????????¬??????????????£?????????.
    seg[2 * k + 1].lazy = max(seg[2 * k + 1].lazy, seg[k].lazy);
  }
  seg[k].lazy = 0;
}

inline void update_node(
    int k) { // k???????????¢?????????????????????????????¨?????????.
             // ????????\\????????¨????????????????????????????????????????????????????????§if???????????????.
  seg[k].sum = max(seg[2 * k].sum, seg[2 * k + 1].sum);
}

// update(l,r,v) := [l,r]?????´??°??????. ?????????1-indexed.
void update(int l, int r, int v, int k = 1, int a = 1, int b = Seg_Max_N) {
  if (l < 0 || r < 0)
    assert(false);
  lazy_evaluate_node(
      k, a,
      b); // ??¨?????????????????£???????????????????????????????????§?????¬?????¨???????\\?.

  if (b < l || r < a) //[a,b]??¨[l,r]???????????????????????´???
    return;
  if (l <= a && b <= r) { // [l,r]???[a,b]????????¨???????????§????????´???
    seg[k].lazy = max(seg[k].lazy, v);
    lazy_evaluate_node(
        k, a, b); //???????????¶???????????¨???????????¨?????????????????§.
    return;
  }

  int m = (a + b) / 2;
  update(l, r, v, 2 * k, a, m);
  update(l, r, v, 2 * k + 1, m + 1, b);
  update_node(k);
}

// get(l,r) := [l,r]?????????????????¨?????????????????????. ?????????1-indexed.
int get(int l, int r, int k = 1, int a = 1, int b = Seg_Max_N) {
  if (l < 0 || r < 0)
    assert(false);
  lazy_evaluate_node(
      k, a,
      b); // ??¨?????????????????£???????????????????????????????????§?????¬?????¨???????\\?.

  if (b < l || r < a) //[a,b]??¨[l,r]???????????????????????´???
    return 0;

  if (l <= a && b <= r) { // [l,r]???[a,b]????????¨???????????§????????´???
    return seg[k].sum;
  }

  int m = (a + b) / 2;
  int vl = get(l, r, 2 * k, a, m);
  int vr = get(l, r, 2 * k + 1, m + 1, b);
  update_node(k);
  return vl + vr;
}

void dfs(const int now, vector<pair<int, int>> &ps, vector<int> &ids, int &id,
         const vector<vector<int>> &edges) {
  ids[now] = id;
  ps[now].first = id;
  id++;
  for (auto e : edges[now]) {
    dfs(e, ps, ids, id, edges);
  }
  ps[now].second = id - 1;
}

int main() {
  while (1) {
    for (int i = 0; i < 2 * Seg_Max_N; ++i) {
      seg[i] = NODE();
    }
    int N, Q;
    cin >> N >> Q;
    if (!N)
      break;
    vector<vector<int>> edges(N);
    for (int i = 0; i < N - 1; ++i) {
      int a;
      cin >> a;
      edges[a - 1].push_back(i + 1);
    }
    vector<pair<int, int>> ps(N);
    vector<int> ids(N);
    vector<int> revids(N);
    int id = 0;
    dfs(0, ps, ids, id, edges);
    for (int i = 0; i < ids.size(); ++i) {
      revids[ids[i]] = i;
    }
    long long int sum = 0;
    for (int i = 0; i < Q; ++i) {
      char c;
      cin >> c;
      if (c == 'Q') {
        int a;
        cin >> a;
        a--;
        int aid = ids[a];
        int ans = get(aid, aid);
        ans = revids[ans];
        sum += ans + 1;
        // cout << ans+1 << endl;
      } else {
        int a;
        cin >> a;
        a--;
        update(ps[a].first, ps[a].second, ids[a]);
      }
    }
    cout << sum << endl;
  }

  return 0;
}

Error: -11

Fixed submission:

#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//< "D:\\D_Download\\Visual Studio
//2015\\Projects\\programing_contest_c++\\Debug\\a.txt"

#define Seg_Max_N (1 << 18)
// update(l,r,v) := [l,r]?????????????????????v???????§?????¶????.
// k,a,b????£????

struct NODE {
  int sum; //??´??°????????????.
           //?????????????????§??????????????????????????¨????????????????????????????????????.
  int lazy; //?????¶???????????????????????????????????????
  NODE() { sum = lazy = 0; }
};

NODE seg[2 * Seg_Max_N];

// inline??????????????¨??§???????????¨????????????!(??????)
inline void lazy_evaluate_node(int k, int a, int b) {
  seg[k].sum = max(seg[k].sum, seg[k].lazy);
  if (k <
      Seg_Max_N) { // 2*k(???????????????) < 2*N (???????????°)
                   // ?????????????????§.
                   // ???????????????????????????????????¬???????????¨??????.
    seg[2 * k].lazy =
        max(seg[2 * k].lazy,
            seg[k].lazy); //?¬???????????????¬??????????????£?????????.
    seg[2 * k + 1].lazy += max(seg[2 * k + 1].lazy, seg[k].lazy);
  }
  seg[k].lazy = 0;
}

inline void update_node(
    int k) { // k???????????¢?????????????????????????????¨?????????.
             // ????????\\????????¨????????????????????????????????????????????????????????§if???????????????.
  seg[k].sum = max(seg[2 * k].sum, seg[2 * k + 1].sum);
}

// update(l,r,v) := [l,r]?????´??°??????. ?????????1-indexed.
void update(int l, int r, int v, int k = 1, int a = 1, int b = Seg_Max_N) {
  if (l < 0 || r < 0)
    assert(false);
  lazy_evaluate_node(
      k, a,
      b); // ??¨?????????????????£???????????????????????????????????§?????¬?????¨???????\\?.

  if (b < l || r < a) //[a,b]??¨[l,r]???????????????????????´???
    return;
  if (l <= a && b <= r) { // [l,r]???[a,b]????????¨???????????§????????´???
    seg[k].lazy = max(seg[k].lazy, v);
    lazy_evaluate_node(
        k, a, b); //???????????¶???????????¨???????????¨?????????????????§.
    return;
  }

  int m = (a + b) / 2;
  update(l, r, v, 2 * k, a, m);
  update(l, r, v, 2 * k + 1, m + 1, b);
  update_node(k);
}

// get(l,r) := [l,r]?????????????????¨?????????????????????. ?????????1-indexed.
int get(int l, int r, int k = 1, int a = 1, int b = Seg_Max_N) {
  if (l < 0 || r < 0)
    assert(false);
  lazy_evaluate_node(
      k, a,
      b); // ??¨?????????????????£???????????????????????????????????§?????¬?????¨???????\\?.

  if (b < l || r < a) //[a,b]??¨[l,r]???????????????????????´???
    return 0;

  if (l <= a && b <= r) { // [l,r]???[a,b]????????¨???????????§????????´???
    return seg[k].sum;
  }

  int m = (a + b) / 2;
  int vl = get(l, r, 2 * k, a, m);
  int vr = get(l, r, 2 * k + 1, m + 1, b);
  update_node(k);
  return max(vl, vr);
}

class Tree {
public:
  Tree(int V, int root) : V(V), root(root), cnum(V), place(V), id(V) {
    T.resize(V);
    for (int i = 0; i < MAXLOGV; i++) {
      parent[i].resize(V);
    }
    depth.resize(V);
  }
  // u??¨v????????????
  // lca????±????????????¨????????????????????§????????°????????¨????????????
  void unite(int u, int v) {
    T[u].push_back(v);
    T[v].push_back(u);
  }
  // init??????
  // ????????????????????????????????????????????????????????°????????¨lca????±???????????????????
  void init() {
    dfs(root, 0, 0);
    int id = 0;
    getid(root, 0, id);
  }
  // u??¨v???lca????±???????
  int lca(int u, int v) const {
    if (depth[u] > depth[v])
      swap(u, v);
    for (int k = 0; k < MAXLOGV; k++) {
      if ((depth[v] - depth[u]) >> k & 1) {
        v = parent[k][v];
      }
    }
    if (u == v)
      return u;
    for (int k = MAXLOGV - 1; k >= 0; k--) {
      if (parent[k][u] != parent[k][v]) {
        u = parent[k][u];
        v = parent[k][v];
      }
    }
    return parent[0][u];
  }
  // u??¨v????????¢????±???????
  // edge????????????????????¨????????????????????????????????????
  int dist(int u, int v) const {
    int p = lca(u, v);
    return (depth[u] - depth[p]) + (depth[v] - depth[p]);
  }
  int dfs(int v, int p, int d) {
    parent[0][v] = p;
    depth[v] = d;
    cnum[v] = 0;
    for (int i = 1; i < MAXLOGV; i++) {
      parent[i][v] = parent[i - 1][parent[i - 1][v]];
    }
    for (int next : T[v]) {
      if (next != p)
        cnum[v] += dfs(next, v, d + 1);
    }
    return cnum[v] + 1;
  }

  void getid(const int v, const int p, int &nplace) {
    place[v] = nplace;
    id[nplace] = v;
    nplace++;
    for (int next : T[v]) {
      if (next != p)
        getid(next, v, nplace);
    }
  }
  static const int MAXLOGV = 25;
  // ??°???????????£??\\???????????¨???
  vector<vector<int>> T;
  // ???????????°
  int V;
  // ?????????????????????
  int root;

  // ????????????
  vector<int> parent[MAXLOGV];
  // ??????????????±???
  vector<int> depth;

  //????????°
  vector<int> cnum;

  //??????
  vector<int> place;
  vector<int> id;
};
int main() {
  while (1) {
    int N, Q;
    cin >> N >> Q;
    update(1, N, 0);
    vector<int> nums;
    nums.push_back(0);
    Tree t(N, 0);
    for (int i = 0; i < N - 1; ++i) {
      int a;
      cin >> a;
      a--;
      t.unite(a, i + 1);
    }
    t.init();
    int asum = 0;
    while (Q--) {
      char c;
      int n;
      cin >> c >> n;
      const int aplace = t.place[n];
      if (c == 'M') {
        update(aplace + 1, aplace + t.cnum[n - 1] + 1, n - 1);
      } else {
        int ans = get(aplace, aplace);
        asum += ans + 1;
      }
    }
    cout << asum << endl;
  }
  return 0;
}