Problem p02575 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>

#define MOD 1000000007
#define MOD2 998244353
#define int long long
#define double long double
#define EPS 1e-9
// #define PI 3.14159265358979

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

using namespace std;

template <typename T> ostream &operator<<(ostream &os, const vector<T> &A) {
  for (int i = 0; i < A.size(); i++)
    os << A[i] << " ";
  os << endl;
  return os;
}
template <> ostream &operator<<(ostream &os, const vector<vector<int>> &A) {
  int N = A.size();
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < A[i].size(); j++)
      os << A[i][j] << " ";
    os << endl;
  }
  return os;
}

typedef pair<int, int> pii;
typedef long long ll;

struct edge {
  int from, to, d, c;
  edge(int _from = 0, int _to = 0, int _d = 0, int _c = 0) {
    from = _from;
    to = _to;
    d = _d;
    c = _c;
  }
  bool operator<(const edge &rhs) const {
    return (d == rhs.d) ? (c < rhs.c) : (d < rhs.d);
  }
};
struct aabb {
  int x1, y1, x2, y2;
  aabb(int x1, int y1, int x2, int y2) : x1(x1), y1(y1), x2(x2), y2(y2) {}
};

typedef vector<edge> edges;
typedef vector<edges> graph;
struct flow {
  int to, cap, rev, cost;
  flow(int to = 0, int cap = 0, int rev = 0, int cost = 0)
      : to(to), cap(cap), rev(rev), cost(cost) {}
};
typedef vector<vector<flow>> flows;

const int di[4] = {0, -1, 0, 1};
const int dj[4] = {-1, 0, 1, 0};
const int ci[5] = {0, 0, -1, 0, 1};
const int cj[5] = {0, -1, 0, 1, 0};
const ll LINF = LLONG_MAX / 2;
const int INF = INT_MAX / 2;
const double PI = acos(-1);

int pow2(int n) { return 1LL << n; }
template <typename T, typename U> bool chmin(T &x, const U &y) {
  if (x > y) {
    x = y;
    return true;
  }
  return false;
}
template <typename T, typename U> bool chmax(T &x, const U &y) {
  if (x < y) {
    x = y;
    return true;
  }
  return false;
}

template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
  fill((T *)array, (T *)(array + N), val);
}
struct initializer {
  initializer() { cout << fixed << setprecision(20); }
};
initializer _____;
template <class Monoid, class Action> struct LSegT {
  int N;
  vector<Monoid> node;
  vector<Action> lazy;
  Monoid UNITY_MONOID; // to be set------------------------
  Action UNITY_ACTION; // to be set------------------------
  Monoid merge(const Monoid &l, const Monoid &r) {
    // to be set---------------------------------
    // return l+r;
    return;
  }
  LSegT(vector<Monoid> &A) {
    int sz = A.size();
    N = 1;
    while (N < sz)
      N <<= 1;
    node.resize(2 * N - 1);
    lazy.resize(2 * N - 1, 0);
    rep(i, sz) node[i + N - 1] = A[i];
    for (int i = N - 2; i >= 0; i--)
      node[i] = merge(node[i * 2 + 1], node[i * 2 + 2]);
  }
  void reflect(int k, int l, int r) {
    // to be set----------------------------------------
    // node[k]+=lazy[k];
  }
  void add(Action &d, const Action &e) {
    // to be set---------------------------------------
    // d+=e;
  }
  void eval(int k, int l, int r) {
    if (lazy[k] != UNITY_ACTION) {
      reflect(k, l, r);
      if (r - l > 1) {

        add(lazy[2 * k + 1], lazy[k]);
        add(lazy[2 * k + 2], lazy[k]);
        // if p,use this
        // add(lazy[2 * k + 1], lazy[k] / 2);
        // add(lazy[2 * k + 2], lazy[k] / 2);
      }
      lazy[k] = UNITY_ACTION;
    }
  }
  void set(int a, int b, Action x, int k = 0, int l = 0, int r = -1) {
    if (r < 0)
      r = N;
    if (b <= l || r <= a)
      eval(k, l, r);
    else if (a <= l && r <= b) {
      add(lazy[k], x);
      // if p,use this
      // add(lazy[k] , (r - l) * x);
      eval(k, l, r);
    } else {
      eval(k, l, r);
      set(a, b, x, 2 * k + 1, l, (l + r) / 2);
      set(a, b, x, 2 * k + 2, (l + r) / 2, r);
      node[k] = merge(node[2 * k + 1], node[2 * k + 2]);
    }
  }
  Monoid get(int a, int b, int k = 0, int l = 0, int r = -1) {
    if (r < 0)
      r = N;
    if (b <= l || r <= a)
      return UNITY_MONOID;
    eval(k, l, r);
    if (a <= l && r <= b)
      return node[k];
    Monoid vl = get(a, b, 2 * k + 1, l, (l + r) / 2);
    Monoid vr = get(a, b, 2 * k + 2, (l + r) / 2, r);
    return node[k] = merge(vl, vr);
  }
};
template <class Monoid> struct SegT {
  // to be set--------------------------------------------------
  const static Monoid UNITY = LINF; // UNITY=0
  Monoid merge(const Monoid &a, const Monoid &b) {
    return min(a, b); // a+b;
  }
  // kokomade----------------------------------------------------
  vector<Monoid> container;
  int n;
  void update(int i, Monoid x) {
    int ii = i + n - 1;
    container[ii] = x;
    while (ii > 0) {
      ii = (ii - 1) / 2;
      container[ii] = merge(container[2 * ii + 1], container[2 * ii + 2]);
    }
  }
  Monoid get(int l, int r, int l2 = 0, int r2 = -1, int k = 0) {
    if (r2 == -1)
      r2 = n;
    if (r2 <= l || r <= l2)
      return UNITY;

    if (l <= l2 && r2 <= r)
      return container[k];
    ll vl = get(l, r, l2, (l2 + r2) / 2, 2 * k + 1);
    ll vr = get(l, r, (l2 + r2) / 2, r2, 2 * k + 2);

    return merge(vl, vr);
  }
  void init(vector<Monoid> &A) {
    n = 1;
    while (n < A.size())
      n <<= 1;
    container = vector<Monoid>(2 * n - 1, 0);
    for (int i = 0; i < A.size(); i++)
      update(i, A[i]);
  }
  SegT(vector<Monoid> &A) { init(A); }
  SegT(int _n) {
    vector<Monoid> A(_n, UNITY);
    init(A);
  }
};
int N, M, K, T, Q, H, W;
signed main() {
  cin >> H >> W;
  vector<int> A(H), B(W);
  rep(i, H) {
    cin >> A[i] >> B[i];
    --A[i];
    --B[i];
  }
  vector<int> tmp(W, 0);
  SegT<int> sgt(tmp);
  map<int, int> m;
  rep(i, W) m[i] = i;
  vector<int> ans(H, LINF);
  rep(i, H) {
    auto it = m.lower_bound(A[i]);
    int r = -1;
    while (it != m.end() && it->first <= B[i]) {
      sgt.update(it->second, LINF);
      chmax(r, it->second);
      // cerr << it->second << " " << it->first << endl;
      it = m.erase(it);
    }
    // cerr << r << endl;
    if (r != -1 && B[i] < W - 1) {
      chmax(m[B[i] + 1], r);
      sgt.update(m[B[i] + 1], B[i] - m[B[i] + 1] + 1);
    }
    // cerr << sgt.get(0, W) << endl;
    // rep(j, W) cerr << sgt.get(j, j + 1) << " ";
    // cout << endl;
    ans[i] = sgt.get(0, W) + i + 1;
  }
  rep(i, H) {
    if (ans[i] >= LINF)
      ans[i] = -1;
    cout << ans[i] << endl;
  }
  return 0;
}

Fixed submission:
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>

#define MOD 1000000007
#define MOD2 998244353
#define int long long
#define double long double
#define EPS 1e-9
// #define PI 3.14159265358979

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

using namespace std;

template <typename T> ostream &operator<<(ostream &os, const vector<T> &A) {
  for (int i = 0; i < A.size(); i++)
    os << A[i] << " ";
  os << endl;
  return os;
}
template <> ostream &operator<<(ostream &os, const vector<vector<int>> &A) {
  int N = A.size();
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < A[i].size(); j++)
      os << A[i][j] << " ";
    os << endl;
  }
  return os;
}

typedef pair<int, int> pii;
typedef long long ll;

struct edge {
  int from, to, d, c;
  edge(int _from = 0, int _to = 0, int _d = 0, int _c = 0) {
    from = _from;
    to = _to;
    d = _d;
    c = _c;
  }
  bool operator<(const edge &rhs) const {
    return (d == rhs.d) ? (c < rhs.c) : (d < rhs.d);
  }
};
struct aabb {
  int x1, y1, x2, y2;
  aabb(int x1, int y1, int x2, int y2) : x1(x1), y1(y1), x2(x2), y2(y2) {}
};

typedef vector<edge> edges;
typedef vector<edges> graph;
struct flow {
  int to, cap, rev, cost;
  flow(int to = 0, int cap = 0, int rev = 0, int cost = 0)
      : to(to), cap(cap), rev(rev), cost(cost) {}
};
typedef vector<vector<flow>> flows;

const int di[4] = {0, -1, 0, 1};
const int dj[4] = {-1, 0, 1, 0};
const int ci[5] = {0, 0, -1, 0, 1};
const int cj[5] = {0, -1, 0, 1, 0};
const ll LINF = LLONG_MAX / 2;
const int INF = INT_MAX / 2;
const double PI = acos(-1);

int pow2(int n) { return 1LL << n; }
template <typename T, typename U> bool chmin(T &x, const U &y) {
  if (x > y) {
    x = y;
    return true;
  }
  return false;
}
template <typename T, typename U> bool chmax(T &x, const U &y) {
  if (x < y) {
    x = y;
    return true;
  }
  return false;
}

template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
  fill((T *)array, (T *)(array + N), val);
}
struct initializer {
  initializer() { cout << fixed << setprecision(20); }
};
initializer _____;
template <class Monoid, class Action> struct LSegT {
  int N;
  vector<Monoid> node;
  vector<Action> lazy;
  Monoid UNITY_MONOID; // to be set------------------------
  Action UNITY_ACTION; // to be set------------------------
  Monoid merge(const Monoid &l, const Monoid &r) {
    // to be set---------------------------------
    // return l+r;
    return;
  }
  LSegT(vector<Monoid> &A) {
    int sz = A.size();
    N = 1;
    while (N < sz)
      N <<= 1;
    node.resize(2 * N - 1);
    lazy.resize(2 * N - 1, 0);
    rep(i, sz) node[i + N - 1] = A[i];
    for (int i = N - 2; i >= 0; i--)
      node[i] = merge(node[i * 2 + 1], node[i * 2 + 2]);
  }
  void reflect(int k, int l, int r) {
    // to be set----------------------------------------
    // node[k]+=lazy[k];
  }
  void add(Action &d, const Action &e) {
    // to be set---------------------------------------
    // d+=e;
  }
  void eval(int k, int l, int r) {
    if (lazy[k] != UNITY_ACTION) {
      reflect(k, l, r);
      if (r - l > 1) {

        add(lazy[2 * k + 1], lazy[k]);
        add(lazy[2 * k + 2], lazy[k]);
        // if p,use this
        // add(lazy[2 * k + 1], lazy[k] / 2);
        // add(lazy[2 * k + 2], lazy[k] / 2);
      }
      lazy[k] = UNITY_ACTION;
    }
  }
  void set(int a, int b, Action x, int k = 0, int l = 0, int r = -1) {
    if (r < 0)
      r = N;
    if (b <= l || r <= a)
      eval(k, l, r);
    else if (a <= l && r <= b) {
      add(lazy[k], x);
      // if p,use this
      // add(lazy[k] , (r - l) * x);
      eval(k, l, r);
    } else {
      eval(k, l, r);
      set(a, b, x, 2 * k + 1, l, (l + r) / 2);
      set(a, b, x, 2 * k + 2, (l + r) / 2, r);
      node[k] = merge(node[2 * k + 1], node[2 * k + 2]);
    }
  }
  Monoid get(int a, int b, int k = 0, int l = 0, int r = -1) {
    if (r < 0)
      r = N;
    if (b <= l || r <= a)
      return UNITY_MONOID;
    eval(k, l, r);
    if (a <= l && r <= b)
      return node[k];
    Monoid vl = get(a, b, 2 * k + 1, l, (l + r) / 2);
    Monoid vr = get(a, b, 2 * k + 2, (l + r) / 2, r);
    return node[k] = merge(vl, vr);
  }
};
template <class Monoid> struct SegT {
  // to be set--------------------------------------------------
  const static Monoid UNITY = LINF; // UNITY=0
  Monoid merge(const Monoid &a, const Monoid &b) {
    return min(a, b); // a+b;
  }
  // kokomade----------------------------------------------------
  vector<Monoid> container;
  int n;
  void update(int i, Monoid x) {
    int ii = i + n - 1;
    container[ii] = x;
    while (ii > 0) {
      ii = (ii - 1) / 2;
      container[ii] = merge(container[2 * ii + 1], container[2 * ii + 2]);
    }
  }
  Monoid get(int l, int r, int l2 = 0, int r2 = -1, int k = 0) {
    if (r2 == -1)
      r2 = n;
    if (r2 <= l || r <= l2)
      return UNITY;

    if (l <= l2 && r2 <= r)
      return container[k];
    ll vl = get(l, r, l2, (l2 + r2) / 2, 2 * k + 1);
    ll vr = get(l, r, (l2 + r2) / 2, r2, 2 * k + 2);

    return merge(vl, vr);
  }
  void init(vector<Monoid> &A) {
    n = 1;
    while (n < A.size())
      n <<= 1;
    container = vector<Monoid>(2 * n - 1, 0);
    for (int i = 0; i < A.size(); i++)
      update(i, A[i]);
  }
  SegT(vector<Monoid> &A) { init(A); }
  SegT(int _n) {
    vector<Monoid> A(_n, UNITY);
    init(A);
  }
};
int N, M, K, T, Q, H, W;
signed main() {
  cin >> H >> W;
  vector<int> A(H), B(H);
  rep(i, H) {
    cin >> A[i] >> B[i];
    --A[i];
    --B[i];
  }
  vector<int> tmp(W, 0);
  SegT<int> sgt(tmp);
  map<int, int> m;
  rep(i, W) m[i] = i;
  vector<int> ans(H, LINF);
  rep(i, H) {
    auto it = m.lower_bound(A[i]);
    int r = -1;
    while (it != m.end() && it->first <= B[i]) {
      sgt.update(it->second, LINF);
      chmax(r, it->second);
      // cerr << it->second << " " << it->first << endl;
      it = m.erase(it);
    }
    // cerr << r << endl;
    if (r != -1 && B[i] < W - 1) {
      chmax(m[B[i] + 1], r);
      sgt.update(m[B[i] + 1], B[i] - m[B[i] + 1] + 1);
    }
    // cerr << sgt.get(0, W) << endl;
    // rep(j, W) cerr << sgt.get(j, j + 1) << " ";
    // cout << endl;
    ans[i] = sgt.get(0, W) + i + 1;
  }
  rep(i, H) {
    if (ans[i] >= LINF)
      ans[i] = -1;
    cout << ans[i] << endl;
  }
  return 0;
}