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

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

unsigned long long xor128() {
  static unsigned long long rx = 123456789, ry = 362436069, rz = 521288629,
                            rw = 88675123;
  unsigned long long rt = (rx ^ (rx << 11));
  rx = ry;
  ry = rz;
  rz = rw;
  return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
}

template <class T> class treap {
public:
  struct node {
    T val, sum, mini, maxi;
    node *left, *right;
    bool init;
    int pri;
    unsigned sz;
    node() {
      sum = 0;
      mini = INT_MAX;
      maxi = INT_MIN;
      sz = 1;
      init = true;
      pri = xor128();
      left = right = NULL;
    }
    node(T val, int pri) : val(val), pri(pri), sz(1) {
      init = false;
      sum = val;
      mini = val;
      maxi = val;
      left = right = NULL;
    }
  };

  node *root;

  treap() : root(NULL) {}

  treap(int n) : root(NULL) {
    for (int i = 0; i < n; i++) {
      init_insert();
    }
  }

  unsigned size() { return size(root); }
  unsigned size(node *v) { return !v ? 0 : v->sz; }
  T sum(node *v) { return !v ? 0 : v->sum; }
  T MIN(node *v) { return !v ? INT_MAX : v->mini; }
  T MAX(node *v) { return !v ? INT_MIN : v->maxi; }

  node *update(node *v) {
    v->sz = size(v->left) + size(v->right) + 1;
    v->sum = sum(v->left) + sum(v->right) + (v->init ? 0 : v->val);
    v->mini = min(v->init ? INT_MAX : v->val, min(MIN(v->left), MIN(v->right)));
    v->maxi = max(v->init ? INT_MIN : v->val, max(MAX(v->left), MAX(v->right)));
    return v;
  }

  node *merge(node *s, node *t) {
    if (!s || !t)
      return s ? s : t;
    if (s->pri > t->pri) {
      s->right = merge(s->right, t);
      return update(s);
    } else {
      t->left = merge(s, t->left);
      return update(t);
    }
  }

  pair<node *, node *> split(node *v, unsigned k) {

    if (!v)
      return pair<node *, node *>(NULL, NULL);

    if (k <= size(v->left)) {
      pair<node *, node *> s = split(v->left, k);
      v->left = s.second;
      return make_pair(s.first, update(v));
    }

    else {
      pair<node *, node *> s = split(v->right, k - size(v->left) - 1);
      v->right = s.first;
      return make_pair(update(v), s.second);
    }
  }

  node *find(unsigned k) {
    node *v = root;
    while (v) {
      unsigned s = size(v->left);
      if (s > k)
        v = v->left;
      else if (s == k)
        break;
      else {
        v = v->right;
        k -= s + 1;
      }
    }
    return v;
  }

  void point_add(int k, T val) { point_add(root, k, val); }
  void point_add(node *v, int k, T val) {
    if (k < size(v->left))
      point_add(v->left, k, val);
    else if (k > size(v->left))
      point_add(v->right, k - size(v->left) - 1, val);
    else
      v->val += val, v->init = false;
    update(v);
  }

  void point_update(int k, T val) { point_update(root, k, val); }
  void point_update(node *v, int k, T val) {
    if (k < size(v->left))
      point_update(v->left, k, val);
    else if (k > size(v->left))
      point_update(v->right, k - size(v->left) - 1, val);
    else
      v->val = val, v->init = false;
    // cout<<v->mini<<endl;
    update(v);
    // cout<<v->mini<<endl;
  }

  // [ l , r )
  int range_query(unsigned l, unsigned r, int Q) {
    T val;

    pair<node *, node *> R = split(root, r);
    pair<node *, node *> L = split(R.first, l);
    node *M = L.second;

    if (Q == 1)
      val = M->mini;
    if (Q == 2)
      val = M->maxi;
    if (Q == 3)
      val = M->sum;

    // cout<<M->right->mini<<endl<<endl;

    root = merge(merge(L.first, M), R.second);

    return val;
  }

  int getval(int k) {
    node *t = find(k);
    return t->val;
  }

  void init_insert() {
    node *t = root;
    int k = 0;
    pair<node *, node *> s = split(t, k);
    t = merge(s.first, new node());
    t = merge(t, s.second);
    root = update(t);
  }
  void insert(unsigned k, T val) { root = insert(root, k, val, xor128()); }
  node *insert(node *t, unsigned k, T val, int pri) {
    pair<node *, node *> s = split(t, k);
    t = merge(s.first, new node(val, pri));
    t = merge(t, s.second);
    return update(t);
  }

  void erase(int k) { root = root->sz == 1 ? NULL : erase(root, k); }
  node *erase(node *t, unsigned k) {
    pair<node *, node *> u, v;
    u = split(t, k + 1);
    v = split(u.first, k);
    t = merge(v.first, u.second);
    return update(t);
  }

  void range_erase(int l, int r) { root = range_erase(root, l, r); }
  node range_erase(node *t, unsigned k) { pair<node *, node *> u, v; }

  void push_back(T val) { insert(root ? root->sz : 0, val); }
  void pop_back() { erase(root->sz - 1); }

  void print_array() {
    int k = root->sz;
    cout << "root value = " << root->val << endl;
    cout << "size of array = " << k << endl;
    for (int i = 0; i < k; i++) {
      if (i)
        cout << " ";
      cout << getval(i);
    }
    cout << endl;
  }

  void print_tree() {
    for (int i = 0; i < root->sz; i++) {
      cout << i << ' ' << endl;
      node *v = find(i);
      cout << "left = " << (!v->left ? 9 : v->left->val) << endl;
      cout << "right = " << (!v->right ? 9 : v->right->val) << endl;
    }
  }
};

int main() {
  int n, q;
  cin >> n >> q;
  treap<int> tri(n);
  while (q--) {
    int a, b, c;
    cin >> a >> b >> c;
    if (a) {
      c++;
      cout << tri.range_query(b, c, 1) << endl;
    } else {
      tri.point_update(b, c);
    }
    // tri.print_tree();
  }
}


Error: -11

Fixed submission:

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

#define INF 1e9
template <class T> class treap {
public:
  unsigned long long xor128() {
    static unsigned long long rx = 123456789, ry = 362436069, rz = 521288629,
                              rw = 88675123;
    unsigned long long rt = (rx ^ (rx << 11));
    rx = ry;
    ry = rz;
    rz = rw;
    return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
  }

  struct node {
    T val, sum, mini, maxi;
    node *left, *right;
    int pri;
    unsigned sz;
    node(T val, int pri)
        : val(val), sum(val), mini(val), maxi(val), pri(pri), sz(1) {
      left = right = NULL;
    }
  };

  node *root;

  treap() : root(NULL) {}

  treap(int n) : root(NULL) {
    for (int i = 0; i < n; i++) {
      insert(0, 0);
    }
  }

  unsigned size() { return size(root); }
  unsigned size(node *v) { return !v ? 0 : v->sz; }
  T sum(node *v) { return !v ? 0 : v->sum; }
  T MIN(node *v) { return !v ? INF : v->mini; }
  T MAX(node *v) { return !v ? -INF : v->maxi; }

  node *update(node *v) {
    v->sz = size(v->left) + size(v->right) + 1;
    v->sum = sum(v->left) + sum(v->right) + v->val;
    v->mini = min(v->val, min(MIN(v->left), MIN(v->right)));
    v->maxi = max(v->val, max(MAX(v->left), MAX(v->right)));
    return v;
  }

  node *merge(node *s, node *t) {
    if (!s || !t)
      return s ? s : t;
    if (s->pri > t->pri) {
      s->right = merge(s->right, t);
      return update(s);
    } else {
      t->left = merge(s, t->left);
      return update(t);
    }
  }

  pair<node *, node *> split(node *v, unsigned k) {

    if (!v)
      return pair<node *, node *>(NULL, NULL);

    if (k <= size(v->left)) {
      pair<node *, node *> s = split(v->left, k);
      v->left = s.second;
      return make_pair(s.first, update(v));
    }

    else {
      pair<node *, node *> s = split(v->right, k - size(v->left) - 1);
      v->right = s.first;
      return make_pair(update(v), s.second);
    }
  }

  node *find(unsigned k) {
    node *v = root;
    while (v) {
      unsigned s = size(v->left);
      if (s > k)
        v = v->left;
      else if (s == k)
        break;
      else {
        v = v->right;
        k -= s + 1;
      }
    }
    return v;
  }

  void point_add(int k, T val) { point_add(root, k, val); }
  void point_add(node *v, int k, T val) {
    if (k < size(v->left))
      point_add(v->left, k, val);
    else if (k > size(v->left))
      point_add(v->right, k - size(v->left) - 1, val);
    else
      v->val += val;
    update(v);
  }

  void point_update(int k, T val) { point_update(root, k, val); }
  void point_update(node *v, int k, T val) {
    if (k < size(v->left))
      point_update(v->left, k, val);
    else if (k > size(v->left))
      point_update(v->right, k - size(v->left) - 1, val);
    else
      v->val = val;
    update(v);
  }

  // [ l , r )
  int range_query(unsigned l, unsigned r, int Q) {
    T val;

    pair<node *, node *> R = split(root, r);
    pair<node *, node *> L = split(R.first, l);
    node *M = L.second;

    if (Q == 1)
      val = M->mini;
    if (Q == 2)
      val = M->maxi;
    if (Q == 3)
      val = M->sum;

    root = merge(merge(L.first, M), R.second);

    return val;
  }

  int getval(int k) {
    node *t = find(k);
    return t->val;
  }

  void insert(unsigned k, T val) { root = insert(root, k, val, xor128()); }
  node *insert(node *t, unsigned k, T val, int pri) {
    pair<node *, node *> s = split(t, k);
    t = merge(s.first, new node(val, pri));
    t = merge(t, s.second);
    return update(t);
  }

  void erase(int k) { root = root->sz == 1 ? NULL : erase(root, k); }
  node *erase(node *t, unsigned k) {
    pair<node *, node *> u, v;
    u = split(t, k + 1);
    v = split(u.first, k);
    t = merge(v.first, u.second);
    return update(t);
  }

  void range_erase(int l, int r) { root = range_erase(root, l, r); }
  node range_erase(node *t, unsigned k) { pair<node *, node *> u, v; }

  void push_back(T val) { insert(root ? root->sz : 0, val); }
  void pop_back() { erase(root->sz - 1); }

  void print_array() {
    int k = root->sz;
    cout << "root value = " << root->val << endl;
    cout << "size of array = " << k << endl;
    for (int i = 0; i < k; i++) {
      if (i)
        cout << " ";
      cout << getval(i);
    }
    cout << endl;
  }

  void print_tree() {
    for (int i = 0; i < root->sz; i++) {
      cout << i << ' ' << endl;
      node *v = find(i);
      cout << "left = " << (!v->left ? 9 : v->left->val) << endl;
      cout << "right = " << (!v->right ? 9 : v->right->val) << endl;
    }
  }
};

int main() {
  int n, q;
  cin >> n >> q;
  treap<int> tri(n);
  while (q--) {
    int a, b, c;
    cin >> a >> b >> c;
    if (a) {
      b--;
      cout << tri.range_query(b, c, 1) << endl;
    } else {
      b--;
      tri.point_update(b, c);
    }
    // tri.print_array();
  }
}