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

#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
  fast_ios() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
  };
} fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, begin, end)                                                     \\
  for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end)                                                    \\
  for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
  vec.resize(len);
  for (auto &v : vec)
    ndarray(v, args...);
}
template <typename T> bool chmax(T &m, const T q) {
  if (m < q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T> bool chmin(T &m, const T q) {
  if (m > q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
  return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
  return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (auto &v : vec)
    is >> v;
  return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (auto v : vec)
    os << v << ",";
  os << "]";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
  os << "deq[";
  for (auto v : vec)
    os << v << ",";
  os << "]";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
  os << "(" << pa.first << "," << pa.second << ")";
  return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
  os << "{";
  for (auto v : mp)
    os << v.first << "=>" << v.second << ",";
  os << "}";
  return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
  os << "{";
  for (auto v : mp)
    os << v.first << "=>" << v.second << ",";
  os << "}";
  return os;
}
#define dbg(x)                                                                 \\
  cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds; // find_by_order(), order_of_key()
template<typename TK> using pbds_set = tree<TK, null_type, less<TK>,
rb_tree_tag, tree_order_statistics_node_update>; template<typename TK, typename
TV> using pbds_map = tree<TK, TV, less<TK>, rb_tree_tag,
tree_order_statistics_node_update>;
*/
bool DBG = false;

struct rand_int_ {
  using lint = long long;
  mt19937 mt;
  rand_int_() : mt(chrono::steady_clock::now().time_since_epoch().count()) {}
  lint operator()(lint x) { return this->operator()(0, x); } // [0, x)
  lint operator()(lint l, lint r) {
    uniform_int_distribution<lint> d(l, r - 1);
    return d(mt);
  }
} rnd;

int main() {
  int N;
  cin >> N;
  vector<int> V(N + 1), W(N + 1);
  FOR(i, 1, N + 1) cin >> V[i] >> W[i];

  if (DBG) {
    N = (1 << 18) - 1;
    V.resize(N, 1);
    W.resize(N, 1);
  }

  int Q;
  cin >> Q;
  vector<vector<pint>> i2qw(N + 1);
  REP(q, Q) {
    int v, w;
    cin >> v >> w;
    i2qw[v].emplace_back(q, w);
  }

  if (DBG) {
    FOR(q, Q, 1e5) {
      int v = rnd(1, 100001), w = rnd(1, 100000);
      i2qw[v].emplace_back(q, w);
    }
    Q = 1e5;
  }

  vector<int> ret(Q);
  int lmax = 101010;
  vector<int> nv(lmax, 0);

  vector<pint> conb{{0, 0}}, conb_mem;
  int dth = 9;

  auto dfs = [&](auto &&dfs, int now, int depth) -> void {
    if (now > N)
      return;
    int v = V[now], w = W[now];
    pint p(v, w);
    int n = conb.size();
    conb.resize(n * 2);
    FOR(i, n, n * 2) conb[i] = conb[i - n] + p;

    if (depth == dth) {
      nv.assign(lmax, 0);
      for (auto [v, w] : conb)
        if (w < lmax)
          chmax(nv[w], v);
      REP(i, lmax - 1) chmax(nv[i + 1], nv[i]);

      conb_mem = conb;
      conb = {{0, 0}};
    }

    for (auto [q, wlimit] : i2qw[now])
      if (wlimit < lmax) {
        for (auto [v, w] : conb)
          if (w <= wlimit) {
            chmax(ret[q], v + nv[wlimit - w]);
          }
      }

    if (now * 2 <= N)
      dfs(dfs, now * 2, depth + 1);
    if (now * 2 + 1 <= N)
      dfs(dfs, now * 2 + 1, depth + 1);

    if (depth == dth) {
      nv.assign(lmax, 0);
      conb = conb_mem;
      conb_mem.clear();
    }
    conb.resize(n);
  };

  dfs(dfs, 1, 0);
  for (auto r : ret)
    cout << r << '\\n';
}


Error: 0

Fixed submission:

#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
  fast_ios() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
  };
} fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, begin, end)                                                     \\
  for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end)                                                    \\
  for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
  vec.resize(len);
  for (auto &v : vec)
    ndarray(v, args...);
}
template <typename T> bool chmax(T &m, const T q) {
  if (m < q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T> bool chmin(T &m, const T q) {
  if (m > q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
  return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
  return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (auto &v : vec)
    is >> v;
  return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (auto v : vec)
    os << v << ",";
  os << "]";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
  os << "deq[";
  for (auto v : vec)
    os << v << ",";
  os << "]";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
  os << "{";
  for (auto v : vec)
    os << v << ",";
  os << "}";
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
  os << "(" << pa.first << "," << pa.second << ")";
  return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
  os << "{";
  for (auto v : mp)
    os << v.first << "=>" << v.second << ",";
  os << "}";
  return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
  os << "{";
  for (auto v : mp)
    os << v.first << "=>" << v.second << ",";
  os << "}";
  return os;
}
#define dbg(x)                                                                 \\
  cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds; // find_by_order(), order_of_key()
template<typename TK> using pbds_set = tree<TK, null_type, less<TK>,
rb_tree_tag, tree_order_statistics_node_update>; template<typename TK, typename
TV> using pbds_map = tree<TK, TV, less<TK>, rb_tree_tag,
tree_order_statistics_node_update>;
*/

// Nonrecursive Segment Tree (point-update, range-get)
// - Conditions for operations:
//   - merge_data: [TDATA, TDATA] -> TDATA, e(x, y) == e(y, x)
//   - data2ret: [TDATA, TQUERY] -> TRET
//   - merge_ret: [TRET, TRET] -> TRET, g(defaultRET, x) == x, g(x, y) = g(y, x)
//   - commutability f(e(x, y), q) == g(f(x, q), f(y, q))
template <typename TDATA, typename TRET, typename TQUERY>
struct NonrecursiveSegmentTree {
  int N;
  TRET defaultRET;
  virtual TDATA merge_data(const TDATA &, const TDATA &) = 0;
  virtual TRET data2ret(const TDATA &, const TQUERY &) = 0;
  virtual TRET merge_ret(const TRET &, const TRET &) = 0;
  std::vector<TDATA> data;
  inline TDATA &at(int i) { return data[i]; }

  inline void _merge(int i) {
    at(i) = merge_data(at(i << 1), at((i << 1) + 1));
  }
  void initialize(const std::vector<TDATA> &seq, TRET RET_ZERO) {
    N = seq.size();
    defaultRET = RET_ZERO;
    data = seq;
    data.insert(data.end(), seq.begin(), seq.end());
    for (int i = N - 1; i; i--)
      _merge(i);
  }
  NonrecursiveSegmentTree() = default;
  void update(int pos, const TDATA &x) {
    assert(pos >= 0 and pos < N);
    at(pos + N) = x;
    for (int i = pos + N; i > 1;)
      i >>= 1, _merge(i);
  }

  // [l, r), 0-indexed
  TRET get(int l, int r, TQUERY query = NULL) {
    assert(l >= 0 and r <= N);
    TRET retl = defaultRET, retr = defaultRET;
    l += N, r += N;
    while (l < r) {
      if (l & 1)
        retl = merge_ret(retl, data2ret(data[l++], query));
      if (r & 1)
        retr = merge_ret(data2ret(data[--r], query), retr);
      l >>= 1, r >>= 1;
    }
    return merge_ret(retl, retr);
  }

  // Calculate smallest r that satisfies g(f(x_l, q), ..., f(x_{r - 1}, q)) >=
  // threshold Assumption: Monotonicity of g(x_l, ..., x_r) about r (l: fixed)
  // Complexity: O(log N)
  int binary_search(int l, const TRET &threshold, TQUERY query = NULL) {
    std::stack<int> rs;
    l += N;
    int r = N * 2;
    TRET retl = defaultRET;
    if (threshold <= retl)
      return l - N;
    while (l < r) {
      if (l & 1) {
        TRET ret_tmp = merge_ret(retl, data2ret(data[l], query));
        if (threshold <= ret_tmp) {
          while (l * 2 < N * 2) {
            ret_tmp = merge_ret(retl, data2ret(data[l * 2], query));
            if (threshold <= ret_tmp)
              l *= 2;
            else
              retl = ret_tmp, l = l * 2 + 1;
          }
          return l - N;
        }
        l++;
        retl = ret_tmp;
      }
      if (r & 1)
        rs.push(--r);
      l >>= 1, r >>= 1;
    }
    while (!rs.empty()) {
      l = rs.top();
      rs.pop();
      TRET ret_tmp = merge_ret(retl, data2ret(data[l], query));
      if (threshold <= ret_tmp) {
        while (l * 2 < N * 2) {
          ret_tmp = merge_ret(retl, data2ret(data[l * 2], query));
          if (threshold <= ret_tmp)
            l *= 2;
          else
            retl = ret_tmp, l = l * 2 + 1;
        }
        return l - N;
      }
      retl = ret_tmp;
    }
    return N;
  }

  template <typename T1, typename T2, typename T3>
  friend std::ostream &operator<<(std::ostream &os,
                                  NonrecursiveSegmentTree<T1, T2, T3> s) {
    os << "[SegmentTree (len: " << s.N << ')';
    for (int i = 0; i < s.N; i++)
      os << s.at(i + s.N) << ',';
    os << "]";
    return os;
  }
};

// Range Maximum Query
// - get: return max(x_l, ..., x_{r - 1})
template <typename T>
struct RangeMaximumQuery : public NonrecursiveSegmentTree<T, T, bool> {
  using SegTree = NonrecursiveSegmentTree<T, T, bool>;
  T merge_data(const T &vl, const T &vr) override { return std::max(vl, vr); };
  T data2ret(const T &v, const bool &q) override { return v; }
  T merge_ret(const T &vl, const T &vr) override { return std::max(vl, vr); };
  RangeMaximumQuery(const std::vector<T> &seq, T defaultmax)
      : SegTree::NonrecursiveSegmentTree() {
    SegTree::initialize(seq, defaultmax);
  };
};

int main() {
  int N;
  cin >> N;
  vector<int> V(N + 1), W(N + 1);
  FOR(i, 1, N + 1) cin >> V[i] >> W[i];

  if (false) {
    N = (1 << 18) - 1;
    V.resize(N, 1);
    W.resize(N, 1);
  }
  int Q;
  cin >> Q;
  vector<vector<pint>> i2qw(N + 1);
  REP(q, Q) {
    int v, w;
    cin >> v >> w;
    i2qw[v].emplace_back(q, w);
  }

  vector<int> ret(Q);
  int lmax = 100001;

  vector<int> nv(lmax, 0);

  vector<pint> conb{{0, 0}}, conb_mem;
  int dth = 9;

  auto dfs = [&](auto &&dfs, int now, int depth) -> void {
    if (now > N)
      return;
    int v = V[now], w = W[now];
    pint p(v, w);
    int n = conb.size();
    conb.resize(n * 2);
    FOR(i, n, n * 2) conb[i] = conb[i - n] + p;

    if (depth == dth) {
      nv.assign(lmax, 0);
      for (auto [v, w] : conb)
        if (v < lmax) {
          chmax(nv[w], v);
        }
      REP(i, lmax - 1) chmax(nv[i + 1], nv[i]);

      conb_mem = conb;
      conb = {{0, 0}};
    }

    for (auto [q, wt] : i2qw[now]) {
      // dbg(q);
      // dbg(conb);
      for (auto [v, w] : conb)
        if (w <= wt) {
          chmax(ret[q], v + nv[wt - w]);
        }
    }

    if (now * 2 <= N)
      dfs(dfs, now * 2, depth + 1);
    if (now * 2 + 1 <= N)
      dfs(dfs, now * 2 + 1, depth + 1);

    if (depth == dth) {
      nv.assign(lmax, 0);
      conb = conb_mem;
    }

    conb.resize(n);
  };

  dfs(dfs, 1, 0);
  for (auto r : ret)
    cout << r << '\\n';
}