Problem p00998 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>

using namespace std;

#define L 250

#define INF 1000000000

struct RMQ {
  vector<vector<int>> v;
  vector<int> m;
  void shift(int l, int r) {
    int pos = 0;
    int rv = -1;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (pos <= r && r < np) {
        int j = r - pos;
        rv = v[i][j];
        v[i].erase(v[i].begin() + j);
        updateMin(i);
        break;
      }
      pos = np;
    }

    pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (pos <= l && l < np) {
        int j = l - pos;
        v[i].insert(v[i].begin() + j, rv);
        updateMin(i);
      }
      pos = np;
    }
  }
  int get(int l, int r) {
    int ret = INF;
    int pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (l <= pos && np - 1 <= r) {
        ret = min(ret, m[i]);
      } else if (pos <= r && l < np) {
        for (int j = 0; j < v[i].size(); ++j) {
          if (l <= pos + j && pos + j <= r) {
            ret = min(ret, v[i][j]);
          }
        }
      }
      pos = np;
    }
    return ret;
  }
  void update(int x, int val) {
    int pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (pos <= x && x < np) {
        v[i][x - pos] = val;
        updateMin(i);
        break;
      }
      pos = np;
    }
  }
  void updateMin(int pos) {
    m[pos] = INF;
    for (int i = 0; i < v[pos].size(); ++i) {
      m[pos] = min(m[pos], v[pos][i]);
    }
  }
  void smooth() {
    vector<int> a;
    for (int i = 0; i < v.size(); ++i) {
      for (int j = 0; j < v[i].size(); ++j) {
        a.push_back(v[i][j]);
      }
    }
    init(a);
  }
  void init(vector<int> a) {
    int N = a.size();
    v.clear();
    v.resize((N - 1) / L + 2); // N > 0
    m = vector<int>(v.size(), INF);

    int pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      for (int j = 0; j < L; ++j) {
        if (pos + j < N) {
          v[i].push_back(a[pos + j]);
        }
      }
      updateMin(i);
      pos += L;
    }
  }
};

int main() {
  RMQ rmq;
  int N, Q;
  cin >> N >> Q;
  vector<int> v(N);
  for (int i = 0; i < N; ++i) {
    cin >> v[i];
  }
  rmq.init(v);
  for (int t = 0; t < Q; ++t) {
    int x, y, z;
    cin >> x >> y >> z;
    switch (x) {
    case 0:
      rmq.shift(y, z);
      break;

    case 1:
      cout << rmq.get(y, z) << endl;
      break;

    case 2:
      rmq.update(y, z);
      break;
    }
    if (t % L == 0) {
      rmq.smooth();
    }
  }
}

Error: TLE

Fixed submission:

#include <bits/stdc++.h>

using namespace std;

#define L 10

#define INF 1000000000

struct RMQ {
  vector<vector<int>> v;
  vector<int> m;
  void shift(int l, int r) {
    int pos = 0;
    int rv = -1;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (pos <= r && r < np) {
        int j = r - pos;
        rv = v[i][j];
        v[i].erase(v[i].begin() + j);
        break;
      }
      pos = np;
    }

    pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (pos <= l && l < np) {
        int j = l - pos;
        v[i].insert(v[i].begin() + j, rv);
      }
      pos = np;
    }
  }
  int get(int l, int r) {
    int ret = INF;
    int pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (l <= pos && np - 1 <= r) {
        ret = min(ret, m[i]);
      } else if (pos <= r && l < np) {
        for (int j = 0; j < v[i].size(); ++j) {
          if (l <= pos + j && pos + j <= r) {
            ret = min(ret, v[i][j]);
          }
        }
      }
      pos = np;
    }
    return ret;
  }
  void update(int x, int val) {
    int pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      int np = pos + v[i].size();
      if (pos <= x && x < np) {
        for (int j = 0; j < v[i].size(); ++j) {
          if (pos + j == x) {
            v[i][j] = val;
            break;
          }
        }
        int nv = INF;
        for (int j = 0; j < v[i].size(); ++j) {
          nv = min(nv, v[i][j]);
        }
        m[i] = nv;
        return;
      }
      pos = np;
    }
  }
  void smooth() {
    vector<int> a;
    for (int i = 0; i < v.size(); ++i) {
      for (int j = 0; j < v[i].size(); ++j) {
        a.push_back(v[i][j]);
      }
    }
    init(a);
  }
  void init(vector<int> a) {
    int N = a.size();
    v.clear();
    v.resize((N - 1) / L + 2); // N > 0
    m = vector<int>(v.size(), INF);

    int pos = 0;
    for (int i = 0; i < v.size(); ++i) {
      for (int j = 0; j < L; ++j) {
        if (pos + j < N) {
          v[i].push_back(a[pos + j]);
          m[i] = min(m[i], a[pos + j]);
        }
      }
      pos += L;
    }
  }
};

int main() {
  RMQ rmq;
  int N, Q;
  cin >> N >> Q;
  vector<int> v(N);
  for (int i = 0; i < N; ++i) {
    cin >> v[i];
  }
  rmq.init(v);
  for (int t = 0; t < Q; ++t) {
    int x, y, z;
    cin >> x >> y >> z;
    switch (x) {
    case 0:
      rmq.shift(y, z);
      break;

    case 1:
      cout << rmq.get(y, z) << endl;
      break;

    case 2:
      rmq.update(y, z);
      break;
    }
    rmq.smooth();
    if (t % L == 0) {
      rmq.smooth();
    }
  }
}