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

#include <bits/stdc++.h> // ver2.7.1
#define int long long
#define endl "\\n" // fflush(stdout);
#define ALL(v) (v).begin(), (v).end()
#define Vi vector<int>
#define VVi vector<Vi>
#define VVVi vector<VVi>
#define Vm vector<mint>
#define Vs vector<string>
#define Vd vector<double>
#define Vc vector<char>
#define Pii pair<int, int>
#define Pdd pair<double, double>
#define VPii vector<Pii>
#define Tiii tuple<int, int, int>
#define VTiii vector<Tiii>
#define PQi priority_queue<int>
#define PQir priority_queue<int, vector<int>, greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define itos to_string
#define stoi stoll
#define FI first
#define SE second
#define cYES cout << "YES" << endl
#define cNO cout << "NO" << endl
#define cYes cout << "Yes" << endl
#define cNo cout << "No" << endl
#define cyes cout << "yes" << endl
#define cno cout << "no" << endl
#define sortr(v) sort(v, greater<>())
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repeq(i, a, b) for (int i = a; i <= b; i++)
#define repreq(i, a, b) for (int i = a; i >= b; i--)
#define dem(a, b) ((a + b - 1) / (b))
#define INF 3000000000000000000 // 3.0*10^18
#define MAX LLONG_MAX
#define PI acos(-1.0L)
// int MOD = 998244353; // case
const int MOD = 1000000007; // 10^9 + 7
const double EPS = 1e-4;

using namespace std;

struct mint {
  int x;
  mint(int x = 0) : x((x % MOD + MOD) % MOD) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint a) {
    if ((x += a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += MOD - a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint operator+(const mint a) const { return mint(*this) += a; }
  mint operator-(const mint a) const { return mint(*this) -= a; }
  mint operator*(const mint a) const { return mint(*this) *= a; }
  mint pow(int t) const {
    if (!t)
      return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1)
      a *= *this;
    return a;
  }
  mint inv() const { return pow(MOD - 2); }
  mint &operator/=(const mint a) { return *this *= a.inv(); }
  mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }

/* debug */
template <typename T> // vector
ostream &operator<<(ostream &os, const vector<T> &V) {
  int N = V.size();
  if (N == 0) {
    os << '.';
    return os;
  }
  rep(i, 0, N - 1) { os << V[i] << ' '; }
  os << V[N - 1];
  return os;
}
template <typename T> // vector vector
ostream &operator<<(ostream &os, const vector<vector<T>> &V) {
  int N = V.size();
  rep(i, 0, N - 1) cout << V[i] << endl;
  cout << V[N - 1];
  return os;
}
template <typename T, typename S> // pair
ostream &operator<<(ostream &os, pair<T, S> const &P) {
  os << P.FI << ' ' << P.SE;
  return os;
}
template <typename T> // set
ostream &operator<<(ostream &os, set<T> &S) {
  auto it = S.begin();
  while (it != S.end()) {
    os << *it;
    if (next(it, 1) != S.end())
      os << ' ';
    it++;
  };
  return os;
}
template <typename T> // deque
ostream &operator<<(ostream &os, deque<T> &q) {
  for (auto it = q.begin(); it < q.end(); it++) {
    os << *it;
    if (it + 1 != q.end())
      os << " ";
  }
  return os;
}

/* useful */
template <typename T> void Vin(vector<T> &v) {
  int n = v.size();
  rep(i, 0, n) cin >> v[i];
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int mypow(int x, int n, int m) {
  if (n == 0)
    return 1;
  if (n % 2 == 0)
    return mypow(x * x % m, n / 2, m);
  else
    return x * mypow(x, n - 1, m) % m;
}
int scomb(int n, int r) {
  if (r < 0 || r > n)
    return 0;
  if ((n - r) < r)
    r = n - r; // nCr
  int a = 1;
  for (int i = n; i > n - r; --i) {
    a = a * i;
  }
  for (int i = 1; i < r + 1; ++i) {
    a = a / i;
  }
  return a;
}
Vi vis(Vi &v) {
  Vi S(v.size() + 1);
  rep(i, 1, S.size()) S[i] += v[i - 1] + S[i - 1];
  return S;
}
int digitsum(int n) {
  int ret = 0;
  while (n > 0) {
    ret += n % 10;
    n /= 10;
  }
  return ret;
}
int digit(int k, int i) {
  string s = itos(k);
  return s[s.size() - i] - '0';
} // i桁目の数字
template <typename T> void press(T &v) {
  v.erase(unique(ALL(v)), v.end());
} // 圧縮
Vi zip(Vi b) {
  int Z = b.size(); // 座標圧縮
  Pii p[Z + 10];
  int a = b.size();
  Vi l(a);
  for (int i = 0; i < a; i++)
    p[i] = mp(b[i], i);
  sort(p, p + a);
  int w = 0;
  for (int i = 0; i < a; i++) {
    if (i && p[i].first != p[i - 1].first)
      w++;
    l[p[i].second] = w;
  }
  return l;
}
Vi nibe2V() {
  Vi a(60);
  int q = 1;
  rep(i, 0, 60) {
    a[i] = q;
    q *= 2;
  }
  return a;
}
// Vi nibe = nibe2V(); // 2^n
int modiv(int a, int b) {
  return a * mypow(b, MOD - 2, MOD) % MOD;
} // a÷b(%MOD)
int SMALLER(Vi &a, int x) {
  return lower_bound(a.begin(), a.end(), x) - a.begin();
}
int orSMALLER(Vi &a, int x) {
  return upper_bound(a.begin(), a.end(), x) - a.begin();
}
int BIGGER(Vi &a, int x) { return a.size() - orSMALLER(a, x); }
int orBIGGER(Vi &a, int x) { return a.size() - SMALLER(a, x); }
int COUNT(Vi &a, int x) {
  return upper_bound(ALL(a), x) - lower_bound(ALL(a), x);
}
int maxind(Vi &a) { return max_element(ALL(a)) - a.begin(); }
int minind(Vi &a) { return min_element(ALL(a)) - a.begin(); }
Vi stpowV() {
  Vi a(1000005);
  a[0] = 1;
  repeq(i, 1, 1000004) a[i] = a[i - 1] * i % MOD;
  return a;
}
// Vi stpow = stpowV(); // 階乗配列(%MOD)

/****************************** START ******************************/

using uint = unsigned;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;

template <class D, class I> struct StaticRangeSum {
  struct P {
    I x, y;
    D val;
  };
  int lg;
  V<I> xs, ys;
  V<int> mid;
  VV<int> bits;
  VV<D> sums;
  StaticRangeSum() {}
  StaticRangeSum(V<P> ps) {
    if (!ps.size())
      return;
    sort(ps.begin(), ps.end(), [&](P l, P r) { return l.x < r.x; });
    for (auto p : ps) {
      xs.push_back(p.x);
      ys.push_back(p.y);
    }
    sort(ys.begin(), ys.end());
    ys.erase(unique(ys.begin(), ys.end()), ys.end());
    int n = (int)(xs.size());
    int m = (int)(ys.size());
    lg = 1;
    while ((1 << lg) < m)
      lg++;
    mid = V<int>(lg);
    bits = VV<int>(lg, V<int>(n + 1));
    sums = VV<D>(lg + 1, V<D>(n + 1));
    struct Q {
      int y;
      D val;
    };
    V<Q> v;
    for (auto p : ps) {
      int y = (int)(lower_bound(ys.begin(), ys.end(), p.y) - ys.begin());
      v.push_back({y, p.val});
    }
    for (int i = 0; i < n; i++) {
      Q q = v[i];
      sums[lg][i + 1] = sums[lg][i] + q.val;
    }
    for (int lv = lg - 1; lv >= 0; lv--) {
      array<V<Q>, 2> nx;
      for (int i = 0; i < n; i++) {
        Q q = v[i];
        bool f = (q.y >> lv) & 1;
        bits[lv][i + 1] = bits[lv][i] + (f ? 0 : 1);
        nx[f].push_back(q);
      }
      mid[lv] = (int)(nx[0].size());
      v.clear();
      v.insert(v.end(), nx[0].begin(), nx[0].end());
      v.insert(v.end(), nx[1].begin(), nx[1].end());
      for (int i = 0; i < n; i++) {
        Q q = v[i];
        sums[lv][i + 1] = sums[lv][i] + q.val;
      }
    }
  }
  D sum(int l, int r, int u) {
    if (u == (1 << lg))
      return sums[lg][r] - sums[lg][l];
    D ans = 0;
    for (int lv = lg - 1; lv >= 0; lv--) {
      bool f = (u >> lv) & 1;
      int l0 = bits[lv][l], r0 = bits[lv][r];
      if (f) {
        ans += sums[lv][r0] - sums[lv][l0];
        l = l - l0 + mid[lv];
        r = r - r0 + mid[lv];
      } else {
        l = l0;
        r = r0;
      }
    }
    return ans;
  }
  D sum(I _lx, I _ly, I _ux, I _uy) {
    assert(_lx <= _ux && _ly <= _uy);
    int lx = (int)(lower_bound(xs.begin(), xs.end(), _lx) - xs.begin());
    int ux = (int)(lower_bound(xs.begin(), xs.end(), _ux) - xs.begin());
    int ly = (int)(lower_bound(ys.begin(), ys.end(), _ly) - ys.begin());
    int uy = (int)(lower_bound(ys.begin(), ys.end(), _uy) - ys.begin());
    if (lx == ux || ly == uy)
      return D(0);
    return sum(lx, ux, uy) - sum(lx, ux, ly);
  }
};

struct SUM2D {

  int n;
  int nowi;
  vector<StaticRangeSum<ll, int>::P> ps;
  StaticRangeSum<ll, int> srs;

  SUM2D() {}
  SUM2D(int ct) { init(ct); } // 宣言の際にポイント数を入力

  void init(int ct) {
    n = ct;
    ps = V<StaticRangeSum<ll, int>::P>(ct);
    nowi = 0;
  }

  void add(int x, int y, int val) {
    ps[nowi].x = x;
    ps[nowi].y = y;
    ps[nowi].val = val;
    nowi++;
    if (n == nowi)
      srs = StaticRangeSum<ll, int>(ps);
  }

  int sum(int l, int d, int r, int u) {
    r++;
    u++;
    return srs.sum(l, d, r, u);
  }
  /*　使い方まとめ　*/
  /*
  SUM2D pl(n) // 宣言 n は平面上の点の個数
  pl.add(x,y,val) // どちらも正の座標 (x,y) に val 個の点を追加
  pl.sum(a,b,c,d) // 縦a~c，横b~dの長方形区間内の点の個数を求める(0-index)
  */
};

struct RinR {

  int N;
  int ct;
  SUM2D pl;

  RinR(int n) {
    N = n;
    pl = SUM2D(n);
    ct = 0;
  }

  void add(int l, int r) {
    ct++;
    pl.add(l, r, 1);
  }

  int sum(int l, int r) {
    if (ct != N)
      return -1;
    else
      return pl.sum(l, l, r, r);
  }
  /* 使い方 */
  /*
  RinR rr(n) // 宣言 n は区間数
  rr.add(i,r) // [l,r]の区間を追加
  rr.sum(l,r) // [l,r]内の区間数を返す（※注意 ちょうどn個の区間のときのみ可）
  */
};

signed main() {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(12);
  int n, q;
  cin >> n >> q;
  Vi a(n);
  Vin(a);
  Vi zen(n, -1);

  Vi L, R;

  rep(i, 0, n) {
    a[i]--;
    if (zen[a[i]] != -1) {
      // r.add(zen[a[i]],i);
      L.pb(zen[a[i]]);
      R.pb(i);
    }
    zen[a[i]] = i;
  }

  RinR r(L.size());

  rep(i, 0, L.size()) { r.add(L[i], R[i]); }

  rep(i, 0, q) {
    int qw, er;
    cin >> qw >> er;
    qw--, er--;
    cout << (er - qw + 1) - r.sum(qw, er) << endl;
  }
  return 0;
}


Error: 0

Fixed submission:

#include <bits/stdc++.h> // ver2.7.1
#define int long long
#define endl "\\n" // fflush(stdout);
#define ALL(v) (v).begin(), (v).end()
#define Vi vector<int>
#define VVi vector<Vi>
#define VVVi vector<VVi>
#define Vm vector<mint>
#define Vs vector<string>
#define Vd vector<double>
#define Vc vector<char>
#define Pii pair<int, int>
#define Pdd pair<double, double>
#define VPii vector<Pii>
#define Tiii tuple<int, int, int>
#define VTiii vector<Tiii>
#define PQi priority_queue<int>
#define PQir priority_queue<int, vector<int>, greater<int>>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define itos to_string
#define stoi stoll
#define FI first
#define SE second
#define cYES cout << "YES" << endl
#define cNO cout << "NO" << endl
#define cYes cout << "Yes" << endl
#define cNo cout << "No" << endl
#define cyes cout << "yes" << endl
#define cno cout << "no" << endl
#define sortr(v) sort(v, greater<>())
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repeq(i, a, b) for (int i = a; i <= b; i++)
#define repreq(i, a, b) for (int i = a; i >= b; i--)
#define dem(a, b) ((a + b - 1) / (b))
#define INF 3000000000000000000 // 3.0*10^18
#define MAX LLONG_MAX
#define PI acos(-1.0L)
// int MOD = 998244353; // case
const int MOD = 1000000007; // 10^9 + 7
const double EPS = 1e-4;

using namespace std;

struct mint {
  int x;
  mint(int x = 0) : x((x % MOD + MOD) % MOD) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint a) {
    if ((x += a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += MOD - a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint operator+(const mint a) const { return mint(*this) += a; }
  mint operator-(const mint a) const { return mint(*this) -= a; }
  mint operator*(const mint a) const { return mint(*this) *= a; }
  mint pow(int t) const {
    if (!t)
      return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1)
      a *= *this;
    return a;
  }
  mint inv() const { return pow(MOD - 2); }
  mint &operator/=(const mint a) { return *this *= a.inv(); }
  mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }

/* debug */
template <typename T> // vector
ostream &operator<<(ostream &os, const vector<T> &V) {
  int N = V.size();
  if (N == 0) {
    os << '.';
    return os;
  }
  rep(i, 0, N - 1) { os << V[i] << ' '; }
  os << V[N - 1];
  return os;
}
template <typename T> // vector vector
ostream &operator<<(ostream &os, const vector<vector<T>> &V) {
  int N = V.size();
  rep(i, 0, N - 1) cout << V[i] << endl;
  cout << V[N - 1];
  return os;
}
template <typename T, typename S> // pair
ostream &operator<<(ostream &os, pair<T, S> const &P) {
  os << P.FI << ' ' << P.SE;
  return os;
}
template <typename T> // set
ostream &operator<<(ostream &os, set<T> &S) {
  auto it = S.begin();
  while (it != S.end()) {
    os << *it;
    if (next(it, 1) != S.end())
      os << ' ';
    it++;
  };
  return os;
}
template <typename T> // deque
ostream &operator<<(ostream &os, deque<T> &q) {
  for (auto it = q.begin(); it < q.end(); it++) {
    os << *it;
    if (it + 1 != q.end())
      os << " ";
  }
  return os;
}

/* useful */
template <typename T> void Vin(vector<T> &v) {
  int n = v.size();
  rep(i, 0, n) cin >> v[i];
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int mypow(int x, int n, int m) {
  if (n == 0)
    return 1;
  if (n % 2 == 0)
    return mypow(x * x % m, n / 2, m);
  else
    return x * mypow(x, n - 1, m) % m;
}
int scomb(int n, int r) {
  if (r < 0 || r > n)
    return 0;
  if ((n - r) < r)
    r = n - r; // nCr
  int a = 1;
  for (int i = n; i > n - r; --i) {
    a = a * i;
  }
  for (int i = 1; i < r + 1; ++i) {
    a = a / i;
  }
  return a;
}
Vi vis(Vi &v) {
  Vi S(v.size() + 1);
  rep(i, 1, S.size()) S[i] += v[i - 1] + S[i - 1];
  return S;
}
int digitsum(int n) {
  int ret = 0;
  while (n > 0) {
    ret += n % 10;
    n /= 10;
  }
  return ret;
}
int digit(int k, int i) {
  string s = itos(k);
  return s[s.size() - i] - '0';
} // i桁目の数字
template <typename T> void press(T &v) {
  v.erase(unique(ALL(v)), v.end());
} // 圧縮
Vi zip(Vi b) {
  int Z = b.size(); // 座標圧縮
  Pii p[Z + 10];
  int a = b.size();
  Vi l(a);
  for (int i = 0; i < a; i++)
    p[i] = mp(b[i], i);
  sort(p, p + a);
  int w = 0;
  for (int i = 0; i < a; i++) {
    if (i && p[i].first != p[i - 1].first)
      w++;
    l[p[i].second] = w;
  }
  return l;
}
Vi nibe2V() {
  Vi a(60);
  int q = 1;
  rep(i, 0, 60) {
    a[i] = q;
    q *= 2;
  }
  return a;
}
// Vi nibe = nibe2V(); // 2^n
int modiv(int a, int b) {
  return a * mypow(b, MOD - 2, MOD) % MOD;
} // a÷b(%MOD)
int SMALLER(Vi &a, int x) {
  return lower_bound(a.begin(), a.end(), x) - a.begin();
}
int orSMALLER(Vi &a, int x) {
  return upper_bound(a.begin(), a.end(), x) - a.begin();
}
int BIGGER(Vi &a, int x) { return a.size() - orSMALLER(a, x); }
int orBIGGER(Vi &a, int x) { return a.size() - SMALLER(a, x); }
int COUNT(Vi &a, int x) {
  return upper_bound(ALL(a), x) - lower_bound(ALL(a), x);
}
int maxind(Vi &a) { return max_element(ALL(a)) - a.begin(); }
int minind(Vi &a) { return min_element(ALL(a)) - a.begin(); }
Vi stpowV() {
  Vi a(1000005);
  a[0] = 1;
  repeq(i, 1, 1000004) a[i] = a[i - 1] * i % MOD;
  return a;
}
// Vi stpow = stpowV(); // 階乗配列(%MOD)

/****************************** START ******************************/

/* BIT2D:
    初期値は全て 0
    ・add(h,w,x): (h,w) に x を加算する
    ・sum(h,w): 1≦i≦h かつ 1≦j≦w の範囲の合計値を求める
    ・query(h1,w1,h2,w2): h1≦i<h2 かつ w1≦j<w2 の範囲の合計値を求める(1-indexed)
    計算量は全て O(logW * logH)
*/

template <typename T> struct BIT2D {
  int H, W;
  vector<vector<T>> bit; // データの格納先

  BIT2D() {}

  BIT2D(int H_, int W_) { init(H_, W_); }
  void init(int H_, int W_) {
    H = H_ + 1;
    W = W_ + 1;
    bit.assign(H, vector<T>(W, 0));
  }

  void add(int h, int w, T x) {
    for (int i = h; i < H; i += (i & -i)) {
      for (int j = w; j < W; j += (j & -j)) {
        bit[i][j] += x;
      }
    }
  }
  // 1≦i≦h かつ 1≦j≦w
  T sum(int h, int w) {
    T s(0);
    for (int i = h; i > 0; i -= (i & -i)) {
      for (int j = w; j > 0; j -= (j & -j)) {
        s += bit[i][j];
      }
    }
    return s;
  }

  // h1≦i<h2 かつ w1≦j<w2
  T query(int h1, int w1, int h2, int w2) {
    return sum(h2 - 1, w2 - 1) - sum(h2 - 1, w1 - 1) - sum(h1 - 1, w2 - 1) +
           sum(h1 - 1, w1 - 1);
  }
};

struct RinR {

  int N;
  int sct = 0;
  vector<pair<int, int>> sec;
  BIT2D<int> pl;

  RinR(int n) { // nは最大の要素数以上
    pl = BIT2D<int>(n, n);
    N = n;
  }

  void add(int l, int r) {
    if (l <= r)
      pl.add(l + 1, r + 1, 1);
    /*
    sec.push_back(make_pair(l,r));
    sct++;
    */
  }

  int sum(int l, int r) {

    // return pl.sum(N,N);
    return pl.query(l + 1, l + 1, r + 2, r + 2);
    /*
    int ret = 0;
    rep(i,0,sct) if(l <= sec[i].FI && sec[i].SE <= r) ret++;
    return ret;
    */
  }
};

signed main() {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(12);
  int n, q;
  cin >> n >> q;
  Vi a(n);
  Vin(a);
  Vi zen(n, -1);
  RinR r(n + 5);

  rep(i, 0, n) {
    a[i]--;
    if (zen[a[i]] != -1) {
      r.add(zen[a[i]], i);
    }
    zen[a[i]] = i;
  }

  rep(i, 0, q) {
    int qw, er;
    cin >> qw >> er;
    qw--, er--;
    cout << (er - qw + 1) - r.sum(qw, er) << endl;
  }
  return 0;
}