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

#pragma region kyopro_template
#define Nyaan_template
#include <bits/stdc++.h>
#include <immintrin.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...)                                                               \\
  int __VA_ARGS__;                                                             \\
  in(__VA_ARGS__)
#define inl(...)                                                               \\
  long long __VA_ARGS__;                                                       \\
  in(__VA_ARGS__)
#define ins(...)                                                               \\
  string __VA_ARGS__;                                                          \\
  in(__VA_ARGS__)
#define inc(...)                                                               \\
  char __VA_ARGS__;                                                            \\
  in(__VA_ARGS__)
#define in2(s, t)                                                              \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i]);                                                            \\
  }
#define in3(s, t, u)                                                           \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i]);                                                      \\
  }
#define in4(s, t, u, v)                                                        \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i], v[i]);                                                \\
  }
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define die(...)                                                               \\
  do {                                                                         \\
    out(__VA_ARGS__);                                                          \\
    return;                                                                    \\
  } while (0)
using namespace std;
using ll = long long;
template <class T> using V = vector<T>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename T, typename U> inline bool amin(T &x, U y) {
  return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U> inline bool amax(T &x, U y) {
  return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
  int s = (int)v.size();
  for (int i = 0; i < s; i++)
    os << (i ? " " : "") << v[i];
  return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &x : v)
    is >> x;
  return is;
}
void in() {}
template <typename T, class... U> void in(T &t, U &...u) {
  cin >> t;
  in(u...);
}
void out() { cout << "\\n"; }
template <typename T, class... U> void out(const T &t, const U &...u) {
  cout << t;
  if (sizeof...(u))
    cout << " ";
  out(u...);
}

#ifdef NyaanDebug
#define trc(...)                                                               \\
  do {                                                                         \\
    cerr << #__VA_ARGS__ << " = ";                                             \\
    dbg_out(__VA_ARGS__);                                                      \\
  } while (0)
#define trca(v, N)                                                             \\
  do {                                                                         \\
    cerr << #v << " = ";                                                       \\
    array_out(v, N);                                                           \\
  } while (0)
#define trcc(v)                                                                \\
  do {                                                                         \\
    cerr << #v << " = {";                                                      \\
    each(x, v) { cerr << " " << x << ","; }                                    \\
    cerr << "}" << endl;                                                       \\
  } while (0)
template <typename T> void _cout(const T &c) { cerr << c; }
void _cout(const int &c) {
  if (c == 1001001001)
    cerr << "inf";
  else if (c == -1001001001)
    cerr << "-inf";
  else
    cerr << c;
}
void _cout(const unsigned int &c) {
  if (c == 1001001001)
    cerr << "inf";
  else
    cerr << c;
}
void _cout(const long long &c) {
  if (c == 1001001001 || c == (1LL << 61) - 1)
    cerr << "inf";
  else if (c == -1001001001 || c == -((1LL << 61) - 1))
    cerr << "-inf";
  else
    cerr << c;
}
void _cout(const unsigned long long &c) {
  if (c == 1001001001 || c == (1LL << 61) - 1)
    cerr << "inf";
  else
    cerr << c;
}
template <typename T, typename U> void _cout(const pair<T, U> &p) {
  cerr << "{ ";
  _cout(p.fi);
  cerr << ", ";
  _cout(p.se);
  cerr << " } ";
}
template <typename T> void _cout(const vector<T> &v) {
  int s = v.size();
  cerr << "{ ";
  for (int i = 0; i < s; i++) {
    cerr << (i ? ", " : "");
    _cout(v[i]);
  }
  cerr << " } ";
}
template <typename T> void _cout(const vector<vector<T>> &v) {
  cerr << "[ ";
  for (const auto &x : v) {
    cerr << endl;
    _cout(x);
    cerr << ", ";
  }
  cerr << endl << " ] ";
}
void dbg_out() { cerr << endl; }
template <typename T, class... U> void dbg_out(const T &t, const U &...u) {
  _cout(t);
  if (sizeof...(u))
    cerr << ", ";
  dbg_out(u...);
}
template <typename T> void array_out(const T &v, int s) {
  cerr << "{ ";
  for (int i = 0; i < s; i++) {
    cerr << (i ? ", " : "");
    _cout(v[i]);
  }
  cerr << " } " << endl;
}
template <typename T> void array_out(const T &v, int H, int W) {
  cerr << "[ ";
  for (int i = 0; i < H; i++) {
    cerr << (i ? ", " : "");
    array_out(v[i], W);
  }
  cerr << " ] " << endl;
}
#else
#define trc(...)
#define trca(...)
#define trcc(...)
#endif

inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename T> inline int getbit(T a, int i) { return (a >> i) & 1; }
template <typename T> inline void setbit(T &a, int i) { a |= (1LL << i); }
template <typename T> inline void delbit(T &a, int i) { a &= ~(1LL << i); }
template <typename T> int lb(const vector<T> &v, const T &a) {
  return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int ub(const vector<T> &v, const T &a) {
  return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int btw(T a, T x, T b) { return a <= x && x < b; }
template <typename T, typename U> T ceil(T a, U b) { return (a + b - 1) / b; }
constexpr long long TEN(int n) {
  long long ret = 1, x = 10;
  while (n) {
    if (n & 1)
      ret *= x;
    x *= x;
    n >>= 1;
  }
  return ret;
}
template <typename T> vector<T> mkrui(const vector<T> &v) {
  vector<T> ret(v.size() + 1);
  for (int i = 0; i < int(v.size()); i++)
    ret[i + 1] = ret[i] + v[i];
  return ret;
};
template <typename T> vector<T> mkuni(const vector<T> &v) {
  vector<T> ret(v);
  sort(ret.begin(), ret.end());
  ret.erase(unique(ret.begin(), ret.end()), ret.end());
  return ret;
}
template <typename F> vector<int> mkord(int N, F f) {
  vector<int> ord(N);
  iota(begin(ord), end(ord), 0);
  sort(begin(ord), end(ord), f);
  return ord;
}
template <typename T = int> vector<T> mkiota(int N) {
  vector<T> ret(N);
  iota(begin(ret), end(ret), 0);
  return ret;
}
template <typename T> vector<int> mkinv(vector<T> &v) {
  vector<int> inv(v.size());
  for (int i = 0; i < (int)v.size(); i++)
    inv[v[i]] = i;
  return inv;
}

struct IoSetupNya {
  IoSetupNya() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    cerr << fixed << setprecision(7);
  }
} iosetupnya;

void solve();
int main() { solve(); }

#pragma endregion
using namespace std;

template <typename E, E INF> struct UpdateMin_LazySegmentTree {
  int n, height;
  using T = E;
  T f(T a, T b) { return min(a, b); };
  T g(T, E b) { return b; };
  E h(E, E b) { return b; };
  T ti = INF;
  E ei = INF;
  vector<T> dat;
  vector<E> laz;

  UpdateMin_LazySegmentTree(const vector<E> &v) { build(v); }

  void init(int n_) {
    n = 1;
    height = 0;
    while (n < n_)
      n <<= 1, height++;
    dat.assign(2 * n, ti);
    laz.assign(2 * n, ei);
  }

  void build(const vector<E> &v) {
    int n_ = v.size();
    init(n_);
    for (int i = 0; i < n_; i++)
      dat[n + i] = v[i];
    for (int i = n - 1; i; i--)
      dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]);
  }

  inline T reflect(int k) { return laz[k] == ei ? dat[k] : g(dat[k], laz[k]); }

  inline void propagate(int k) {
    if (laz[k] == ei)
      return;
    laz[(k << 1) | 0] = h(laz[(k << 1) | 0], laz[k]);
    laz[(k << 1) | 1] = h(laz[(k << 1) | 1], laz[k]);
    dat[k] = reflect(k);
    laz[k] = ei;
  }

  inline void thrust(int k) {
    for (int i = height; i; i--)
      propagate(k >> i);
  }

  inline void recalc(int k) {
    while (k >>= 1)
      dat[k] = f(reflect((k << 1) | 0), reflect((k << 1) | 1));
  }

  void update(int a, int b, E x) {
    if (a >= b)
      return;
    thrust(a += n);
    thrust(b += n - 1);
    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
      if (l & 1)
        laz[l] = h(laz[l], x), l++;
      if (r & 1)
        --r, laz[r] = h(laz[r], x);
    }
    recalc(a);
    recalc(b);
  }

  void set_val(int a, T x) {
    thrust(a += n);
    dat[a] = x;
    laz[a] = ei;
    recalc(a);
  }

  T query(int a, int b) {
    if (a >= b)
      return ti;
    thrust(a += n);
    thrust(b += n - 1);
    T vl = ti, vr = ti;
    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
      if (l & 1)
        vl = f(vl, reflect(l++));
      if (r & 1)
        vr = f(reflect(--r), vr);
    }
    return f(vl, vr);
  }
};

void solve() {
  ini(H, W);
  vl a(H), b(H);
  in2(a, b);
  each(x, a) x--;

  UpdateMin_LazySegmentTree<ll, infLL> seg(vl(W, 0));

  vl seg2ini(W);
  rep(i, W) seg2ini[i] = 0 - i;
  UpdateMin_LazySegmentTree<ll, infLL> seg2(seg2ini);

  vl ans(H, -1);
  rep(i, H) {
    ll nx = inf;
    if (b[i] != W) {
      ll mi = seg2.query(a[i], b[i]);
      if (mi < inf)
        nx = mi + b[i];
    }
    trc(i, a[i], b[i]);
    rep(i, W) trc(seg.query(i, i + 1), seg2.query(i, i + 1));
    seg.update(a[i], b[i], inf);
    seg2.update(a[i], b[i], inf);
    rep(i, W) trc(seg.query(i, i + 1), seg2.query(i, i + 1));
    if (nx < inf) {
      if (seg.query(b[i], b[i] + 1) > nx) {
        seg.update(b[i], b[i] + 1, nx);
        seg2.update(b[i], b[i] + 1, nx - b[i]);
      }
    }
    trc(i, a[i], b[i]);
    rep(i, W) trc(seg.query(i, i + 1), seg2.query(i, i + 1));
    ans[i] = i + 1 + seg.query(0, W);
    if (ans[i] >= TEN(6)) {
      ans[i] = -1;
      break;
    }
  }
  each(x, ans) out(x);

  /*
  vi cnt(W + 1, 0);
  int mi = 0;
  cnt[0] = W;
  cnt[W] = inf;
  set<pair<int,int>> s;
  rep(i,W) s.insert(pair<int,int>{i, 0});

  auto ers = [&](pii p){
    cnt[p.second]--;
    if(mi == p.second && cnt[p.second] == 0){
      while(cnt[mi] == 0) mi++;
    }
  };
  auto add = [&](pii p){

  };


  vi ans(H, -1);
  vpi st;
  rep(i, H) {
    st.clear();
    auto it = s.lower_bound({a[i], -inf});
    pii nx;
    if(it->first != a[i]){
      if(it != s.begin()) {
        --it;
        ers(*it);
        nx = {i, it->second + a[i] - it->first};
        ++it;
      } else {
        if(it->first <= b[i]){

        }
      }
    }else {

    }

  }
  */
}

Error: TLE

Fixed submission:

#pragma region kyopro_template
#define Nyaan_template
#include <bits/stdc++.h>
#include <immintrin.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...)                                                               \\
  int __VA_ARGS__;                                                             \\
  in(__VA_ARGS__)
#define inl(...)                                                               \\
  long long __VA_ARGS__;                                                       \\
  in(__VA_ARGS__)
#define ins(...)                                                               \\
  string __VA_ARGS__;                                                          \\
  in(__VA_ARGS__)
#define inc(...)                                                               \\
  char __VA_ARGS__;                                                            \\
  in(__VA_ARGS__)
#define in2(s, t)                                                              \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i]);                                                            \\
  }
#define in3(s, t, u)                                                           \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i]);                                                      \\
  }
#define in4(s, t, u, v)                                                        \\
  for (int i = 0; i < (int)s.size(); i++) {                                    \\
    in(s[i], t[i], u[i], v[i]);                                                \\
  }
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define die(...)                                                               \\
  do {                                                                         \\
    out(__VA_ARGS__);                                                          \\
    return;                                                                    \\
  } while (0)
using namespace std;
using ll = long long;
template <class T> using V = vector<T>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename T, typename U> inline bool amin(T &x, U y) {
  return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U> inline bool amax(T &x, U y) {
  return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
  int s = (int)v.size();
  for (int i = 0; i < s; i++)
    os << (i ? " " : "") << v[i];
  return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &x : v)
    is >> x;
  return is;
}
void in() {}
template <typename T, class... U> void in(T &t, U &...u) {
  cin >> t;
  in(u...);
}
void out() { cout << "\\n"; }
template <typename T, class... U> void out(const T &t, const U &...u) {
  cout << t;
  if (sizeof...(u))
    cout << " ";
  out(u...);
}

#ifdef NyaanDebug
#define trc(...)                                                               \\
  do {                                                                         \\
    cerr << #__VA_ARGS__ << " = ";                                             \\
    dbg_out(__VA_ARGS__);                                                      \\
  } while (0)
#define trca(v, N)                                                             \\
  do {                                                                         \\
    cerr << #v << " = ";                                                       \\
    array_out(v, N);                                                           \\
  } while (0)
#define trcc(v)                                                                \\
  do {                                                                         \\
    cerr << #v << " = {";                                                      \\
    each(x, v) { cerr << " " << x << ","; }                                    \\
    cerr << "}" << endl;                                                       \\
  } while (0)
template <typename T> void _cout(const T &c) { cerr << c; }
void _cout(const int &c) {
  if (c == 1001001001)
    cerr << "inf";
  else if (c == -1001001001)
    cerr << "-inf";
  else
    cerr << c;
}
void _cout(const unsigned int &c) {
  if (c == 1001001001)
    cerr << "inf";
  else
    cerr << c;
}
void _cout(const long long &c) {
  if (c == 1001001001 || c == (1LL << 61) - 1)
    cerr << "inf";
  else if (c == -1001001001 || c == -((1LL << 61) - 1))
    cerr << "-inf";
  else
    cerr << c;
}
void _cout(const unsigned long long &c) {
  if (c == 1001001001 || c == (1LL << 61) - 1)
    cerr << "inf";
  else
    cerr << c;
}
template <typename T, typename U> void _cout(const pair<T, U> &p) {
  cerr << "{ ";
  _cout(p.fi);
  cerr << ", ";
  _cout(p.se);
  cerr << " } ";
}
template <typename T> void _cout(const vector<T> &v) {
  int s = v.size();
  cerr << "{ ";
  for (int i = 0; i < s; i++) {
    cerr << (i ? ", " : "");
    _cout(v[i]);
  }
  cerr << " } ";
}
template <typename T> void _cout(const vector<vector<T>> &v) {
  cerr << "[ ";
  for (const auto &x : v) {
    cerr << endl;
    _cout(x);
    cerr << ", ";
  }
  cerr << endl << " ] ";
}
void dbg_out() { cerr << endl; }
template <typename T, class... U> void dbg_out(const T &t, const U &...u) {
  _cout(t);
  if (sizeof...(u))
    cerr << ", ";
  dbg_out(u...);
}
template <typename T> void array_out(const T &v, int s) {
  cerr << "{ ";
  for (int i = 0; i < s; i++) {
    cerr << (i ? ", " : "");
    _cout(v[i]);
  }
  cerr << " } " << endl;
}
template <typename T> void array_out(const T &v, int H, int W) {
  cerr << "[ ";
  for (int i = 0; i < H; i++) {
    cerr << (i ? ", " : "");
    array_out(v[i], W);
  }
  cerr << " ] " << endl;
}
#else
#define trc(...)
#define trca(...)
#define trcc(...)
#endif

inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename T> inline int getbit(T a, int i) { return (a >> i) & 1; }
template <typename T> inline void setbit(T &a, int i) { a |= (1LL << i); }
template <typename T> inline void delbit(T &a, int i) { a &= ~(1LL << i); }
template <typename T> int lb(const vector<T> &v, const T &a) {
  return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int ub(const vector<T> &v, const T &a) {
  return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename T> int btw(T a, T x, T b) { return a <= x && x < b; }
template <typename T, typename U> T ceil(T a, U b) { return (a + b - 1) / b; }
constexpr long long TEN(int n) {
  long long ret = 1, x = 10;
  while (n) {
    if (n & 1)
      ret *= x;
    x *= x;
    n >>= 1;
  }
  return ret;
}
template <typename T> vector<T> mkrui(const vector<T> &v) {
  vector<T> ret(v.size() + 1);
  for (int i = 0; i < int(v.size()); i++)
    ret[i + 1] = ret[i] + v[i];
  return ret;
};
template <typename T> vector<T> mkuni(const vector<T> &v) {
  vector<T> ret(v);
  sort(ret.begin(), ret.end());
  ret.erase(unique(ret.begin(), ret.end()), ret.end());
  return ret;
}
template <typename F> vector<int> mkord(int N, F f) {
  vector<int> ord(N);
  iota(begin(ord), end(ord), 0);
  sort(begin(ord), end(ord), f);
  return ord;
}
template <typename T = int> vector<T> mkiota(int N) {
  vector<T> ret(N);
  iota(begin(ret), end(ret), 0);
  return ret;
}
template <typename T> vector<int> mkinv(vector<T> &v) {
  vector<int> inv(v.size());
  for (int i = 0; i < (int)v.size(); i++)
    inv[v[i]] = i;
  return inv;
}

struct IoSetupNya {
  IoSetupNya() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    cerr << fixed << setprecision(7);
  }
} iosetupnya;

void solve();
int main() { solve(); }

#pragma endregion
using namespace std;

template <typename T> struct BinaryIndexedTree {
  int N;
  int max_2beki;
  vector<T> data;

  BinaryIndexedTree(int size) {
    N = ++size;
    data.assign(N + 3, 0);
    max_2beki = 1;
    while (max_2beki * 2 <= N)
      max_2beki *= 2;
  }

  // get sum of [0,k]
  T sum(int k) const {
    if (k < 0)
      return 0; // return 0 if k < 0
    T ret = 0;
    for (++k; k > 0; k -= k & -k)
      ret += data[k];
    return ret;
  }

  // getsum of [l,r]
  inline T sum(int l, int r) const { return sum(r) - sum(l - 1); }

  // get value of k
  inline T operator[](int k) const { return sum(k) - sum(k - 1); }

  // data[k] += x
  void add(int k, T x) {
    for (++k; k < N; k += k & -k)
      data[k] += x;
  }

  // range add x to [l,r]
  void imos(int l, int r, T x) {
    add(l, x);
    add(r + 1, -x);
  }

  // minimize i s.t. sum(i) >= w
  int lower_bound(T w) {
    if (w <= 0)
      return 0;
    int x = 0;
    for (int k = max_2beki; k > 0; k /= 2) {
      if (x + k <= N - 1 && data[x + k] < w) {
        w -= data[x + k];
        x += k;
      }
    }
    return x;
  }

  // minimize i s.t. sum(i) > w
  int upper_bound(T w) {
    if (w < 0)
      return 0;
    int x = 0;
    for (int k = max_2beki; k > 0; k /= 2) {
      if (x + k <= N - 1 && data[x + k] <= w) {
        w -= data[x + k];
        x += k;
      }
    }
    return x;
  }
};
using namespace std;

struct UnionFind {
  vector<int> data;
  UnionFind(int N) : data(N, -1) {}

  int find(int k) { return data[k] < 0 ? k : data[k] = find(data[k]); }

  int unite(int x, int y) {
    if ((x = find(x)) == (y = find(y)))
      return false;
    if (data[x] > data[y])
      swap(x, y);
    data[x] += data[y];
    data[y] = x;
    return true;
  }

  int size(int k) { return -data[find(k)]; }

  int same(int x, int y) { return find(x) == find(y); }
};
using namespace std;

long long my_gcd(long long x, long long y) {
  long long z;
  if (x > y)
    swap(x, y);
  while (x) {
    x = y % (z = x);
    y = z;
  }
  return y;
}
long long my_lcm(long long x, long long y) {
  return 1LL * x / my_gcd(x, y) * y;
}
#define gcd my_gcd
#define lcm my_lcm

// Prime -> 1 {0, 0, 1, 1, 0, 1, 0, 1, ...}
vector<int> Primes(int N) {
  vector<int> A(N + 1, 1);
  A[0] = A[1] = 0;
  for (int i = 2; i * i <= N; i++)
    if (A[i] == 1)
      for (int j = i << 1; j <= N; j += i)
        A[j] = 0;
  return A;
}

// Prime Sieve {2, 3, 5, 7, 11, 13, 17, ...}
vector<long long> PrimeSieve(int N) {
  vector<int> prime = Primes(N);
  vector<long long> ret;
  for (int i = 0; i < (int)prime.size(); i++)
    if (prime[i] == 1)
      ret.push_back(i);
  return ret;
}

// Factors (using for fast factorization)
// {0, 0, 1, 1, 2, 1, 2, 1, 2, 3, ...}
vector<int> Factors(int N) {
  vector<int> A(N + 1, 1);
  A[0] = A[1] = 0;
  for (int i = 2; i * i <= N; i++)
    if (A[i] == 1)
      for (int j = i << 1; j <= N; j += i)
        A[j] = i;
  return A;
}

// totient function φ(N)=(1 ~ N , gcd(i,N) = 1)
// {0, 1, 1, 2, 4, 2, 6, 4, ... }
vector<int> EulersTotientFunction(int N) {
  vector<int> ret(N + 1, 0);
  for (int i = 0; i <= N; i++)
    ret[i] = i;
  for (int i = 2; i <= N; i++) {
    if (ret[i] == i)
      for (int j = i; j <= N; j += i)
        ret[j] = ret[j] / i * (i - 1);
  }
  return ret;
}

// Divisor ex) 12 -> {1, 2, 3, 4, 6, 12}
vector<long long> Divisor(long long N) {
  vector<long long> v;
  for (long long i = 1; i * i <= N; i++) {
    if (N % i == 0) {
      v.push_back(i);
      if (i * i != N)
        v.push_back(N / i);
    }
  }
  return v;
}

// Factorization
// ex) 18 -> { (2,1) , (3,2) }
vector<pair<long long, int>> PrimeFactors(long long N) {
  vector<pair<long long, int>> ret;
  for (long long p = 2; p * p <= N; p++)
    if (N % p == 0) {
      ret.emplace_back(p, 0);
      while (N % p == 0)
        N /= p, ret.back().second++;
    }
  if (N >= 2)
    ret.emplace_back(N, 1);
  return ret;
}

// Factorization with Prime Sieve
// ex) 18 -> { (2,1) , (3,2) }
vector<pair<long long, int>> PrimeFactors(long long N,
                                          const vector<long long> &prime) {
  vector<pair<long long, int>> ret;
  for (auto &p : prime) {
    if (p * p > N)
      break;
    if (N % p == 0) {
      ret.emplace_back(p, 0);
      while (N % p == 0)
        N /= p, ret.back().second++;
    }
  }
  if (N >= 2)
    ret.emplace_back(N, 1);
  return ret;
}

// modpow for mod < 2 ^ 31
long long modpow(long long a, long long n, long long mod) {
  a %= mod;
  long long ret = 1;
  while (n > 0) {
    if (n & 1)
      ret = ret * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return ret % mod;
};

// Check if r is Primitive Root
bool isPrimitiveRoot(long long r, long long mod) {
  r %= mod;
  if (r == 0)
    return false;
  auto pf = PrimeFactors(mod - 1);
  for (auto &x : pf) {
    if (modpow(r, (mod - 1) / x.first, mod) == 1)
      return false;
  }
  return true;
}

// Get Primitive Root
long long PrimitiveRoot(long long mod) {
  long long ret = 1;
  while (isPrimitiveRoot(ret, mod) == false)
    ret++;
  return ret;
}

// Euler's phi function
long long phi(long long n) {
  auto pf = PrimeFactors(n);
  long long ret = n;
  for (auto p : pf) {
    ret /= p.first;
    ret *= (p.first - 1);
  }
  return ret;
}

// Extended Euclidean algorithm
// solve : ax + by = gcd(a, b)
// return : pair(x, y)
pair<long long, long long> extgcd(long long a, long long b) {
  if (b == 0)
    return make_pair(1, 0);
  long long x, y;
  tie(y, x) = extgcd(b, a % b);
  y -= a / b * x;
  return make_pair(x, y);
}

// Check if n is Square Number
// true : return d s.t. d * d == n
// false : return -1
long long SqrtInt(long long n) {
  if (n == 0 || n == 1)
    return n;
  long long d = (long long)sqrt(n) - 1;
  while (d * d < n)
    ++d;
  return (d * d == n) ? d : -1;
}

// return a number of n's digit
// zero ... return value if n = 0 (default -> 1)
int isDigit(long long n, int zero = 1) {
  if (n == 0)
    return zero;
  int ret = 0;
  while (n) {
    n /= 10;
    ret++;
  }
  return ret;
}
using namespace std;

// Prime Sieve {2, 3, 5, 7, 11, 13, 17, ...}
vector<int> PrimeTable(int N) {
  vector<bool> sieve(N / 3 + 1, 1);
  for (int p = 5, d = 4, i = 1, sqn = int(sqrt(N) + 0.1); p <= sqn;
       p += d = 6 - d, i++) {
    if (!sieve[i])
      continue;
    for (int q = p * p / 3, r = d * p / 3 + (d * p % 3 == 2), s = 2 * p,
             qe = sieve.size();
         q < qe; q += r = s - r)
      sieve[q] = 0;
  }
  vector<int> ret{2, 3};
  for (int p = 5, d = 4, i = 1; p <= N; p += d = 6 - d, i++)
    if (sieve[i])
      ret.push_back(p);
  while (!ret.empty() && ret.back() > N)
    ret.pop_back();
  return ret;
}

__attribute__((target("avx2"), optimize("O3", "unroll-loops"))) void solve() {
  ini(H, W);
  vi a(H), b(H);
  in2(a, b);
  each(x, a)-- x;

  BinaryIndexedTree<int> bit(W + 10);
  vi start{0, W - 1};
  rep(i, H) {
    if (a[i] && bit.sum(a[i]) == 0)
      start.pb(a[i] - 1);
    bit.imos(a[i], b[i] - 1, 1);
  }

  vi ans(H, inf);
  each(s, start) {
    int cur = s;
    rep(i, H) {
      int nxt;
      if (cur < a[i] || b[i] <= cur)
        nxt = cur;
      else
        nxt = b[i];
      if (nxt == W)
        break;
      cur = nxt;
      amin(ans[i], cur + i - s + 1);
    }
  }
  each(x, ans) out(x == inf ? -1 : x);
}