Problem p02540 (C++)

Buggy submission (status: Time Limit Exceeded):
#include "bits/stdc++.h"

#include <algorithm>

#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
  int x = 0;
  while ((1U << x) < (unsigned int)(n))
    x++;
  return x;
}

// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
  unsigned long index;
  _BitScanForward(&index, n);
  return index;
#else
  return __builtin_ctz(n);
#endif
}

} // namespace internal

} // namespace atcoder

#include <cassert>
#include <vector>

namespace atcoder {

template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
  segtree() : segtree(0) {}
  segtree(int n) : segtree(std::vector<S>(n, e())) {}
  segtree(const std::vector<S> &v) : _n(int(v.size())) {
    log = internal::ceil_pow2(_n);
    size = 1 << log;
    d = std::vector<S>(2 * size, e());
    for (int i = 0; i < _n; i++)
      d[size + i] = v[i];
    for (int i = size - 1; i >= 1; i--) {
      update(i);
    }
  }

  void set(int p, S x) {
    assert(0 <= p && p < _n);
    p += size;
    d[p] = x;
    for (int i = 1; i <= log; i++)
      update(p >> i);
  }

  S get(int p) {
    assert(0 <= p && p < _n);
    return d[p + size];
  }

  S prod(int l, int r) {
    assert(0 <= l && l <= r && r <= _n);
    S sml = e(), smr = e();
    l += size;
    r += size;

    while (l < r) {
      if (l & 1)
        sml = op(sml, d[l++]);
      if (r & 1)
        smr = op(d[--r], smr);
      l >>= 1;
      r >>= 1;
    }
    return op(sml, smr);
  }

  S all_prod() { return d[1]; }

  template <bool (*f)(S)> int max_right(int l) {
    return max_right(l, [](S x) { return f(x); });
  }
  template <class F> int max_right(int l, F f) {
    assert(0 <= l && l <= _n);
    assert(f(e()));
    if (l == _n)
      return _n;
    l += size;
    S sm = e();
    do {
      while (l % 2 == 0)
        l >>= 1;
      if (!f(op(sm, d[l]))) {
        while (l < size) {
          l = (2 * l);
          if (f(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - size;
      }
      sm = op(sm, d[l]);
      l++;
    } while ((l & -l) != l);
    return _n;
  }

  template <bool (*f)(S)> int min_left(int r) {
    return min_left(r, [](S x) { return f(x); });
  }
  template <class F> int min_left(int r, F f) {
    assert(0 <= r && r <= _n);
    assert(f(e()));
    if (r == 0)
      return 0;
    r += size;
    S sm = e();
    do {
      r--;
      while (r > 1 && (r % 2))
        r >>= 1;
      if (!f(op(d[r], sm))) {
        while (r < size) {
          r = (2 * r + 1);
          if (f(op(d[r], sm))) {
            sm = op(d[r], sm);
            r--;
          }
        }
        return r + 1 - size;
      }
      sm = op(d[r], sm);
    } while ((r & -r) != r);
    return 0;
  }

private:
  int _n, size, log;
  std::vector<S> d;

  void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

} // namespace atcoder

using namespace std;
typedef long long li;

li li_min(li x, li y) { return min(x, y); }

li li_min_e() { return 1LL << 60; }

li li_max(li x, li y) { return max(x, y); }

li li_max_e() { return -li_min_e(); }

using min_segtree = atcoder::segtree<li, li_min, li_min_e>;
using max_segtree = atcoder::segtree<li, li_max, li_max_e>;

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  li n;
  cin >> n;
  min_segtree ys(n);
  max_segtree xs(n);
  set<pair<li, li>> xis;
  set<pair<li, li>> yis;
  vector<li> ans(n), ixs, iys;

  for (int i = 0; i < n; ++i) {
    li x, y;
    cin >> x >> y;
    x--;
    y--;
    xis.emplace(x, i);
    yis.emplace(y, i);
    xs.set(y, x);
    ys.set(x, y);
    ixs.push_back(x);
    iys.push_back(y);
  }

  while (not xis.empty()) {
    const li leftmost_x = xis.begin()->first;
    li cur_y = ys.get(leftmost_x);
    li cur_x = leftmost_x;
    while (true) {
      li next_x = xs.prod(cur_y + 1, n);
      if (next_x <= cur_x) {
        break;
      }
      cur_x = next_x;

      li next_y = ys.prod(0, cur_x);
      if (next_y >= cur_y) {
        break;
      }
      cur_y = next_y;
    }

    set<li> uni;
    for (auto p : xis) {
      const li x = p.first;
      if (x <= cur_x) {
        uni.emplace(p.second);
      } else {
        break;
      }
    }
    for (auto p : yis) {
      const li y = p.first;
      if (y >= cur_y) {
        uni.emplace(p.second);
      }
    }
    for (auto i : uni) {
      const li x = ixs[i];
      const li y = iys[i];
      ans[i] = uni.size();
      xis.erase(make_pair(x, i));
      yis.erase(make_pair(y, i));
    }
  }
  for (int i = 0; i < n; ++i) {
    cout << ans[i] << endl;
  }

  return 0;
}


Fixed submission:
#include "bits/stdc++.h"

#include <algorithm>

#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
  int x = 0;
  while ((1U << x) < (unsigned int)(n))
    x++;
  return x;
}

// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
  unsigned long index;
  _BitScanForward(&index, n);
  return index;
#else
  return __builtin_ctz(n);
#endif
}

} // namespace internal

} // namespace atcoder

#include <cassert>
#include <vector>

namespace atcoder {

template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
  segtree() : segtree(0) {}
  segtree(int n) : segtree(std::vector<S>(n, e())) {}
  segtree(const std::vector<S> &v) : _n(int(v.size())) {
    log = internal::ceil_pow2(_n);
    size = 1 << log;
    d = std::vector<S>(2 * size, e());
    for (int i = 0; i < _n; i++)
      d[size + i] = v[i];
    for (int i = size - 1; i >= 1; i--) {
      update(i);
    }
  }

  void set(int p, S x) {
    assert(0 <= p && p < _n);
    p += size;
    d[p] = x;
    for (int i = 1; i <= log; i++)
      update(p >> i);
  }

  S get(int p) {
    assert(0 <= p && p < _n);
    return d[p + size];
  }

  S prod(int l, int r) {
    assert(0 <= l && l <= r && r <= _n);
    S sml = e(), smr = e();
    l += size;
    r += size;

    while (l < r) {
      if (l & 1)
        sml = op(sml, d[l++]);
      if (r & 1)
        smr = op(d[--r], smr);
      l >>= 1;
      r >>= 1;
    }
    return op(sml, smr);
  }

  S all_prod() { return d[1]; }

  template <bool (*f)(S)> int max_right(int l) {
    return max_right(l, [](S x) { return f(x); });
  }
  template <class F> int max_right(int l, F f) {
    assert(0 <= l && l <= _n);
    assert(f(e()));
    if (l == _n)
      return _n;
    l += size;
    S sm = e();
    do {
      while (l % 2 == 0)
        l >>= 1;
      if (!f(op(sm, d[l]))) {
        while (l < size) {
          l = (2 * l);
          if (f(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - size;
      }
      sm = op(sm, d[l]);
      l++;
    } while ((l & -l) != l);
    return _n;
  }

  template <bool (*f)(S)> int min_left(int r) {
    return min_left(r, [](S x) { return f(x); });
  }
  template <class F> int min_left(int r, F f) {
    assert(0 <= r && r <= _n);
    assert(f(e()));
    if (r == 0)
      return 0;
    r += size;
    S sm = e();
    do {
      r--;
      while (r > 1 && (r % 2))
        r >>= 1;
      if (!f(op(d[r], sm))) {
        while (r < size) {
          r = (2 * r + 1);
          if (f(op(d[r], sm))) {
            sm = op(d[r], sm);
            r--;
          }
        }
        return r + 1 - size;
      }
      sm = op(d[r], sm);
    } while ((r & -r) != r);
    return 0;
  }

private:
  int _n, size, log;
  std::vector<S> d;

  void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

} // namespace atcoder

using namespace std;
typedef long long li;

li li_min(li x, li y) { return min(x, y); }

li li_min_e() { return 1LL << 60; }

li li_max(li x, li y) { return max(x, y); }

li li_max_e() { return -li_min_e(); }

using min_segtree = atcoder::segtree<li, li_min, li_min_e>;
using max_segtree = atcoder::segtree<li, li_max, li_max_e>;

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  li n;
  cin >> n;
  min_segtree ys(n);
  max_segtree xs(n);
  set<pair<li, li>> xis;
  set<pair<li, li>> yis;
  vector<li> ans(n), ixs, iys;

  for (int i = 0; i < n; ++i) {
    li x, y;
    cin >> x >> y;
    x--;
    y--;
    xis.emplace(x, i);
    yis.emplace(y, i);
    xs.set(y, x);
    ys.set(x, y);
    ixs.push_back(x);
    iys.push_back(y);
  }

  while (not xis.empty()) {
    const li leftmost_x = xis.begin()->first;
    li cur_y = ys.get(leftmost_x);
    li cur_x = leftmost_x;
    while (true) {
      li next_x = xs.prod(cur_y + 1, n);
      if (next_x <= cur_x) {
        break;
      }
      cur_x = next_x;

      li next_y = ys.prod(0, cur_x);
      if (next_y >= cur_y) {
        break;
      }
      cur_y = next_y;
    }

    set<li> uni;
    for (auto p : xis) {
      const li x = p.first;
      if (x <= cur_x) {
        uni.emplace(p.second);
      } else {
        break;
      }
    }
    for (auto p : yis) {
      const li y = p.first;
      if (y >= cur_y) {
        uni.emplace(p.second);
      } else {
        break;
      }
    }
    for (auto i : uni) {
      const li x = ixs[i];
      const li y = iys[i];
      ans[i] = uni.size();
      xis.erase(make_pair(x, i));
      yis.erase(make_pair(y, i));
    }
  }
  for (int i = 0; i < n; ++i) {
    cout << ans[i] << endl;
  }

  return 0;
}