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

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

#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define mp(a, b) make_pair((a), (b))
#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;
}

/*
template<class T> class treap{
    public:
    struct node{
        T val,sum;
        node *left,*right;
        int pri;
        unsigned sz;
        node(T val,int pri):val(val),sum(sum),pri(pri),sz(1){
            left=right=NULL;
        }
    };

    node *root;
    treap():root(NULL){
        srand(time(NULL));
    }

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

    node *update(node *v){
        v->sz=size(v->left)+size(v->right)+1;
        v->sum=sum(v->left)+sum(v->right)+v->val;
        return v;
    }

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

    pair<node*,node*> split(node *v,unsigned k){ //[0,k),[k,n)
        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));
        }
        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) return v;
            else{
                v=v->right;
                k-=s+1;
            }
        }
        return v;
    }

    void insert(unsigned k,T val){ root=insert(root,k,val,rand()); }
    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=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);
    }
};
*/

template <class T> class treap {
public:
  struct node {
    T val, min;
    node *left, *right;
    int pri;
    unsigned sz;
    node(T val, int pri) : val(val), min(val), pri(pri), sz(1) {
      left = right = NULL;
    }
  };

  node *root;
  treap() : root(NULL) { srand(time(NULL)); }

  unsigned size() { return size(root); }
  unsigned size(node *v) { return !v ? 0 : v->sz; }
  T min(node *v) { return !v ? INF : v->min; }

  node *update(node *v) {
    v->sz = size(v->left) + size(v->right) + 1;
    v->min = std::min({min(v->left), min(v->right), v->val});
    return v;
  }

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

  pair<node *, node *> split(node *v, unsigned k) { //[0,k),[k,n)
    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));
    }
    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)
        return v;
      else {
        v = v->right;
        k -= s + 1;
      }
    }
    return v;
  }

  void insert(unsigned k, T val) { root = insert(root, k, val, rand()); }
  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 = 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);
  }

  //[l,r)
  void shift(int l, int r) {
    pair<node *, node *> u, v, w;
    u = split(root, r);
    v = split(u.first, r - 1);
    w = split(v.first, l);
    merge(merge(w.first, v.second), merge(w.second, u.second));
  }

  void min(int l, int r) {
    pair<node *, node *> u, v;
    u = split(root, r);
    v = split(u.first, l);
    cout << min(v.second) << endl;
    merge(merge(v.first, v.second), u.second);
  }

  void update(int pos, int val) {
    pair<node *, node *> u, v;
    u = split(root, pos + 1);
    v = split(u.first, pos);
    v.second->val = val;
    update(v.second);
    merge(merge(v.first, v.second), u.second);
  }
};

void Solve() {
  int n, q;
  cin >> n >> q;

  treap<int> t;
  rep(i, 0, n) {
    int a;
    cin >> a;
    t.insert(i, a);
  }

  rep(i, 0, q) {
    int x, y, z;
    cin >> x >> y >> z;
    if (x == 0)
      t.shift(y, z + 1);
    else if (x == 1)
      t.min(y, z + 1);
    else
      t.update(y, z);
  }
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  Solve();
  return 0;
}

Error: 0

Fixed submission:

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

#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define mp(a, b) make_pair((a), (b))
#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 INF_ = 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 SplayTree {
  struct Node {
    int x, sz, mini;
    Node *l, *r, *p;
    Node(int x, Node *p) : x(x), sz(1), mini(x), p(p), l(NULL), r(NULL) {}
  };

  Node *root;

  SplayTree() : root(NULL) {}

  Node *Update(Node *n) {
    if (!n)
      return NULL;
    n->mini = n->x;
    n->sz = 1;
    if (n->l) {
      n->mini = min(n->mini, n->l->mini);
      n->sz += n->l->sz;
    }
    if (n->r) {
      n->mini = min(n->mini, n->r->mini);
      n->sz += n->r->sz;
    }
    return n;
  }

  int Size(Node *t) {
    if (!t)
      return 0;
    return t->sz;
  }

  void Rotate(Node *n) {
    Node *p = n->p, *pp = p->p;

    n->p = pp;
    if (pp == NULL)
      root = n;
    else {
      if (p == pp->l)
        pp->l = n;
      else
        pp->r = n;
    }

    p->p = n;
    if (p->l == n) {
      p->l = n->r;
      if (n->r != NULL)
        n->r->p = p;
      n->r = p;
    } else {
      p->r = n->l;
      if (n->l != NULL)
        n->l->p = p;
      n->l = p;
    }
    Update(p);
    Update(n);
  }

  void Splay(Node *n) {
    while (n && n->p) {
      Node *p = n->p, *pp = p->p;
      if (!pp) {
        // zig
        Rotate(n);
      } else {
        if (pp->l == p) {
          if (p->l == n) {
            // zig-zig
            Rotate(p);
            Rotate(n);
          } else if (p->r == n) {
            // zig-zag
            Rotate(n);
            Rotate(n);
          }
        } else if (pp->r == p) {
          if (p->l == n) {
            // zig-zag
            Rotate(n);
            Rotate(n);
          } else if (p->r == n) {
            // zig-zig
            Rotate(p);
            Rotate(n);
          }
        }
      }
    }
  }

  Node *Find(Node *t, int k) { // 1-indexed
    if (!t)
      return NULL;
    int l_sz = Size(t->l), r_sz = Size(t->r);

    if (l_sz + 1 == k)
      return t;
    if (k <= l_sz)
      return Find(t->l, k);
    return Find(t->r, k - l_sz - 1);
  }

  Node *Max(Node *t) {
    if (!t)
      return NULL;
    while (t->r)
      t = t->r;
    return t;
  }

  void Insert(Node *t, int k, int x) {
    Node *p = Find(t, k);
    if (p == NULL) { // 木が空
      root = new Node(x, NULL);
      return;
    }

    Splay(p);
    Node *n = new Node(x, p);
    n->r = p->r;
    if (p->r)
      p->r->p = n;
    p->r = n;
    Splay(n);
  }

  void Erase(Node *t, int k) {
    Node *n = Find(t, k + 1);
    if (!n)
      return;
    Splay(n);

    if (n->l == NULL) {
      root = n->r;
      n->r->p = NULL;
      delete n;
      return;
    }

    Node *new_root = Max(n->l);
    Node *p = new_root->p;
    new_root->p->r = NULL;
    new_root->p = NULL;
    new_root->r = n->r;
    n->r->p = new_root;
    root = new_root;
    while (p != NULL) {
      Update(p);
      p = p->p;
    }
  }

  Node *Merge(Node *l, Node *r) {
    if (l == NULL)
      return root = r;
    if (r == NULL)
      return root = l;
    l = Max(l);
    Splay(l);
    Splay(r);
    l->r = r;
    r->p = l;
    return root = Update(l);
  }

  pair<Node *, Node *> Split(Node *t, int k) { //[,k),[k,)
    if (!t)
      return make_pair((Node *)NULL, (Node *)NULL);
    if (k == 0)
      return make_pair((Node *)NULL, t);
    if (k == Size(t))
      return make_pair(t, (Node *)NULL);
    if (k < 0 || Size(t) < k) {
      dump("split failed");
      dump(Size(t));
      return make_pair((Node *)NULL, (Node *)NULL);
    }
    Node *l = Find(t, k);
    Splay(l);
    Node *r = l->r;
    l->r = NULL;
    if (r)
      r->p = NULL;
    return make_pair(Update(l), r);
  }

  void Query0(int l, int r) {
    pair<Node *, Node *> p1 = Split(root, l);
    pair<Node *, Node *> p2 = Split(p1.second, r - l - 1);
    pair<Node *, Node *> p3 = Split(p2.second, 1);

    //[p1.first,p2.first,p3.first,p3.second]
    dump(Size(p1.first));
    dump(Size(p2.first));
    dump(Size(p3.first));
    dump(Size(p3.second));

    Merge(Merge(p1.first, p3.first), Merge(p2.first, p3.second));
  }

  void Query1(int l, int r) {
    cout << Query1Sub(l, r, root, 0, Size(root)) << endl;
  }

  int Query1Sub(int a, int b, Node *n, int l, int r) {
    if (!n || r <= a || b <= l)
      return INF;
    if (a <= l && r <= b)
      return n->mini;
    int res = INF, k = l + Size(n->l);
    if (a <= k && k < b)
      res = n->x;
    return min({res, Query1Sub(a, b, n->l, l, r - Size(n->r) - 1),
                Query1Sub(a, b, n->r, l + Size(n->l) + 1, r)});
  }

  void Query2(int k, int x) {
    Node *n = Find(root, k + 1);
    if (!n)
      return;
    Splay(n);
    n->x = x;
    Update(n);
  }
};

void Solve() {
  int n, q;
  cin >> n >> q;

  SplayTree t;
  rep(i, 0, n) {
    int a;
    cin >> a;
    t.Insert(t.root, i, a);
  }

  rep(i, 0, q) {
    dump(t.root->sz);
    int x, y, z;
    cin >> x >> y >> z;
    if (x == 0)
      t.Query0(y, z + 1);
    else if (x == 1)
      t.Query1(y, z + 1);
    else
      t.Query2(y, z);
  }
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  Solve();
  return 0;
}