Problem p02373 (C++) — buggy submission, verdict: Memory Limit Exceeded

#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;

template <typename T> class SparseTable {
  using func_t = function<T(T, T)>;
  int n;
  func_t merge;
  vector<vector<T>> t;
  int clz(unsigned int w) {
    return (w & 0xffff0000)
               ? (w & 0xff000000)
                     ? (w & 0xf0000000)   ? (w & 0xc0000000)
                                                ? (w & 0x80000000) ? 0 : 1
                                            : (w & 0xe0000000) ? 2
                                                               : 3
                       : (w & 0xfc000000) ? (w & 0xf8000000) ? 4 : 5
                       : (w & 0xfe000000) ? 6
                                          : 7
                 : (w & 0xfff00000) ? (w & 0xffc00000)
                                          ? (w & 0xff800000) ? 8 : 9
                                      : (w & 0xffe00000) ? 10
                                                         : 11
                 : (w & 0xfffc0000) ? (w & 0xfff80000) ? 12 : 13
                 : (w & 0xfffe0000) ? 14
                                    : 15
           : (w & 0xffffff00) ? (w & 0xfffff000)
                                    ? (w & 0xffffc000)
                                          ? (w & 0xffff8000) ? 16 : 17
                                      : (w & 0xffffe000) ? 18
                                                         : 19
                                : (w & 0xfffffc00) ? (w & 0xfffff800) ? 20 : 21
                                : (w & 0xfffffe00) ? 22
                                                   : 23
           : (w & 0xfffffff0) ? (w & 0xffffffc0)   ? (w & 0xffffff80) ? 24 : 25
                                : (w & 0xffffffe0) ? 26
                                                   : 27
           : (w & 0xfffffffc) ? (w & 0xfffffff8) ? 28 : 29
           : (w & 0xfffffffe) ? 30
                              : 31;
  }

public:
  SparseTable(
      const vector<T> &b, func_t mq = [](T l, T r) { return min(l, r); })
      : merge(mq) {
    n = b.size();
    t.push_back(b);
    for (int i = 2, j = 1; i <= n; i <<= 1, j++) {
      t.push_back(vector<T>());
      for (int k = 0; k + i <= n; k++) {
        t[j].push_back(merge(t[j - 1][k], t[j - 1][k + i / 2]));
      }
    }
  }
  T find(int l, int r) {
    r++;
    assert(l < r);
    unsigned int w = r - l;
    int i = 31 - clz(w);
    return merge(t[i][l], t[i][r - (1 << i)]);
  }
  T operator[](int id) { return t[0][id]; }
};

class LCA {
  int V, rt;
  vector<vector<int>> G;
  vector<int> depth, used, id;
  vector<int> vs, de;
  SparseTable<pii> st;
  void dfs(int s, int d) {
    used[s] = 1;
    vs.push_back(s);
    de.push_back(d);
    for (int v : G[s]) {
      if (!used[v]) {
        dfs(v, d + 1);
        vs.push_back(s);
        de.push_back(d);
      }
    }
  }
  vector<pii> init() {
    dfs(rt, 0);
    for (int i = 0; i < (int)vs.size(); i++) {
      if (id[vs[i]] == -1)
        id[vs[i]] = i;
    }
    vector<pii> r((int)vs.size());
    for (int i = 0; i < (int)vs.size(); i++) {
      r[i] = pii(de[i], vs[i]);
    }
    return r;
  }

public:
  LCA(vector<vector<int>> G_, int rt_ = 0)
      : V(G_.size()), rt(rt_), G(G_), depth(V), used(V), id(V, -1), st(init()) {
    for (int i = 0; i < V; i++)
      depth[i] = st[id[i]].first;
  }
  int calc(int a, int b) {
    return st.find(min(id[a], id[b]), max(id[a], id[b])).second;
  }
  int dist(int a, int b) { return depth[a] + depth[b] - depth[calc(a, b)] * 2; }
};

int main() {
  ios::sync_with_stdio(false), cin.tie(0);
  int n, q;
  cin >> n;
  vector<vector<int>> G(n);
  for (int i = 0, k; i < n; i++) {
    cin >> k;
    for (int j = 0, c; j < k; j++) {
      cin >> c;
      if (c > i) {
        G[i].push_back(c);
        G[c].push_back(i);
      }
    }
  }
  LCA lca(G);
  cin >> q;
  for (int i = 0, u, v; i < q; i++) {
    cin >> u >> v;
    printf("%d\\n", lca.calc(u, v));
  }
  return 0;
}

Error: MLE

Fixed submission:

#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;

template <typename T> class SparseTable {
  using func_t = function<T(T, T)>;
  int n;
  func_t merge;
  vector<vector<T>> t;
  int clz(unsigned int w) {
    return (w & 0xffff0000)
               ? (w & 0xff000000)
                     ? (w & 0xf0000000)   ? (w & 0xc0000000)
                                                ? (w & 0x80000000) ? 0 : 1
                                            : (w & 0xe0000000) ? 2
                                                               : 3
                       : (w & 0xfc000000) ? (w & 0xf8000000) ? 4 : 5
                       : (w & 0xfe000000) ? 6
                                          : 7
                 : (w & 0xfff00000) ? (w & 0xffc00000)
                                          ? (w & 0xff800000) ? 8 : 9
                                      : (w & 0xffe00000) ? 10
                                                         : 11
                 : (w & 0xfffc0000) ? (w & 0xfff80000) ? 12 : 13
                 : (w & 0xfffe0000) ? 14
                                    : 15
           : (w & 0xffffff00) ? (w & 0xfffff000)
                                    ? (w & 0xffffc000)
                                          ? (w & 0xffff8000) ? 16 : 17
                                      : (w & 0xffffe000) ? 18
                                                         : 19
                                : (w & 0xfffffc00) ? (w & 0xfffff800) ? 20 : 21
                                : (w & 0xfffffe00) ? 22
                                                   : 23
           : (w & 0xfffffff0) ? (w & 0xffffffc0)   ? (w & 0xffffff80) ? 24 : 25
                                : (w & 0xffffffe0) ? 26
                                                   : 27
           : (w & 0xfffffffc) ? (w & 0xfffffff8) ? 28 : 29
           : (w & 0xfffffffe) ? 30
                              : 31;
  }

public:
  SparseTable() {}
  SparseTable(
      const vector<T> &b, func_t mq = [](T l, T r) { return min(l, r); })
      : merge(mq) {
    n = b.size();
    t.push_back(b);
    for (int i = 2, j = 1; i <= n; i <<= 1, j++) {
      t.push_back(vector<T>());
      for (int k = 0; k + i <= n; k++) {
        t[j].push_back(merge(t[j - 1][k], t[j - 1][k + i / 2]));
      }
    }
  }
  T find(int l, int r) {
    r++;
    assert(l < r);
    unsigned int w = r - l;
    int i = 31 - clz(w);
    return merge(t[i][l], t[i][r - (1 << i)]);
  }
  T operator[](int id) { return t[0][id]; }
};

class LCA {
  int V, rt;
  vector<vector<int>> G;
  vector<int> depth, used, id;
  vector<int> vs, de;
  SparseTable<pii> st;
  void dfs(int s, int d) {
    used[s] = 1;
    vs.push_back(s);
    de.push_back(d);
    for (int v : G[s]) {
      if (!used[v]) {
        dfs(v, d + 1);
        vs.push_back(s);
        de.push_back(d);
      }
    }
  }

public:
  LCA(int n, int rt_ = 0) : G(n), depth(n), used(n), id(n) {
    V = n;
    rt = rt_;
  }
  void add(int a, int b) {
    G[a].push_back(b);
    G[b].push_back(a);
  }
  void build() {
    fill(used.begin(), used.end(), 0);
    fill(id.begin(), id.end(), -1);
    dfs(rt, 0);
    for (int i = 0; i < (int)vs.size(); i++) {
      if (id[vs[i]] == -1) {
        id[vs[i]] = i;
      }
    }
    vector<pii> r((int)vs.size());
    for (int i = 0; i < (int)vs.size(); i++) {
      r[i] = pii(de[i], vs[i]);
    }
    SparseTable<pii> res(r);
    for (int i = 0; i < V; i++) {
      depth[i] = res[id[i]].first;
    }
    st = res;
  }
  int calc(int a, int b) {
    return st.find(min(id[a], id[b]), max(id[a], id[b])).second;
  }
  int dist(int a, int b) { return depth[a] + depth[b] - depth[calc(a, b)] * 2; }
};

int main() {
  ios::sync_with_stdio(false), cin.tie(0);
  int n, q;
  cin >> n;
  LCA lca(n);
  for (int i = 0, k; i < n; i++) {
    cin >> k;
    for (int j = 0, c; j < k; j++) {
      cin >> c;
      if (c > i)
        lca.add(i, c);
    }
  }
  lca.build();
  cin >> q;
  for (int i = 0, u, v; i < q; i++) {
    cin >> u >> v;
    printf("%d\\n", lca.calc(u, v));
  }
  return 0;
}