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

// Original Code:
// #include <self/utility>
// #include <self/debug>
// #include <self/dsu>
// using namespace std;
//
// struct SegmentTreeMinChange//[)
//{
//     typedef pii T;
//	const T maxValue=mp(inf,-1);
//     const T minValue=mp(-inf,-1);
//	T* dataMax;
//     T* dataMin;
//	T* tag;
//	int nn;
//	int size()
//	{
//		return nn;
//	}
//	void init(int size)
//	{
//		nn=1;
//		while(nn<size)
//		{
//			nn<<=1;
//		}
//		dataMax=new T[nn*2+5];
//         dataMin=new T[nn*2+5];
//		for(int i=0;i<=nn*2;i++)
//		{
//			dataMin[i]=maxValue;
//             dataMax[i]=minValue;
//		}
//	}
//	void build(int a[],int len)
//	{
//		for(int i=0;i<len;i++)
//		{
//			dataMax[i+nn]=mp(a[i],i);
//             dataMin[i+nn]=mp(a[i],i);
//		}
//		for(int i=nn-1;i>=1;i--)
//		{
//			dataMin[i]=min(dataMin[i*2],dataMin[i*2+1]);
//             dataMax[i]=max(dataMax[i*2],dataMax[i*2+1]);
//		}
//	}
//	void erase(int pos)
//	{
//		erase(1,0,nn,pos,pos+1);
//	}
//	void erase(int x,int l,int r,int ql,int qr)
//	{
//		if(l>=qr || r<=ql) return;
//		if(l>=ql && r<=qr)
//		{
//			dataMax[x]=minValue;
//             dataMin[x]=maxValue;
//			return;
//		}
//		erase(x*2,l,l+r>>1,ql,qr);
//		erase(x*2+1,l+r>>1,r,ql,qr);
//		dataMin[x]=min(dataMin[x*2],dataMin[x*2+1]);
//         dataMax[x]=max(dataMax[x*2],dataMax[x*2+1]);
//	}
//     pair <T,T> query(int x,int l,int r,int ql,int qr)
//     {
//         if(r<=ql || l>=qr) return mp(maxValue,minValue);
//         if(l>=ql && r<=qr)
//         {
//             return mp(dataMin[x],dataMax[x]);
//         }
//         pair<T,T> o1=query(x*2,l,l+r>>1,ql,qr);
//         pair<T,T> o2=query(x*2+1,l+r>>1,r,ql,qr);
//         return mp(min(o1.first,o2.first),max(o1.second,o2.second));
//     }
//     inline pair<T,T> query(int l,int r)
//     {
//         return query(1,0,nn,l,r);
//     }
// }sgt;
// DSU dsu;
//
// int n;
// int a[200005];
// int b[200005];
// vector <pair<pii,int> > vSort;
// int dpa[200005];
// int dpb[200005];
// int ans[200005];
// int h[200005];
// int visit[200005];
//
// void dfs(int x)
//{
//	visit[x]=true;
//     while(true)
//     {
//         pii mv=sgt.query(0,x).first;
//         if(mv.first>=h[x]) break;
//         sgt.erase(mv.second);
//         dsu.merge(mv.second,x);
//         dfs(mv.second);
//     }
//     while(true)
//     {
//         pii mv=sgt.query(x+1,n).second;
//         if(mv.first<=h[x]) break;
//         sgt.erase(mv.second);
//         dsu.merge(mv.second,x);
//         dfs(mv.second);
//     }
// }
//
// int main()
//{
//	// freopen("input.txt","r",stdin);
//     cin>>n;
//     for(int i=0;i<n;i++)
//     {
//         scanf("%d%d",a+i,b+i);
//         a[i]--;
//         b[i]--;
//     }
//     for(int i=0;i<n;i++)
//     {
//         vSort.push_back(mp(mp(a[i],b[i]),i));
//     }
//     sort(all(vSort));
//     for(int i=0;i<n;i++)
//     {
//         h[i]=vSort[i].first.second;
//     }
//     dsu.init(n);
//     sgt.init(n);
//     sgt.build(h,n);
//
//     for(int i=0;i<n;i++)
//     {
//     	if(!visit[i]) dfs(i);
//	}
//
//     for(int i=0;i<n;i++)
//     {
//         ans[vSort[i].second]=dsu.getSize(i);
//     }
//     for(int i=0;i<n;i++)
//     {
//         printf("%d\\n",ans[i]);
//     }
//	return 0;
// }

// substituted with C++ Inliner
#ifndef _SELF_UTILITY
#define _SELF_UTILITY 1
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
#define Endl endl
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define over(A)                                                                \\
  {                                                                            \\
    cout << A << endl;                                                         \\
    exit(0);                                                                   \\
  }
#define all(A) A.begin(), A.end()
#define quickcin ios_base::sync_with_stdio(false);
const int mod = 998244353;
const int gmod = 2;
const int inf = 1039074182;
const ll llinf = 1LL * inf * inf;
template <typename T1, typename T2> inline void chmin(T1 &x, T2 b) {
  if (b < x)
    x = b;
}
template <typename T1, typename T2> inline void chmax(T1 &x, T2 b) {
  if (b > x)
    x = b;
}
template <typename T1, typename T2> inline void chadd(T1 &x, T2 b) {
  x += b;
  if (x >= mod)
    x -= mod;
}
template <typename T1, typename T2> inline void chmul(T1 &x, T2 b) {
  x = 1LL * x * b % mod;
}
template <typename T1, typename T2> inline void chmod(T1 &x, T2 b) {
  x %= b, x += b;
  if (x >= b)
    x -= b;
}
#endif

#ifndef _SELF_DEBUG
#define _SELF_DEBUG 1
#ifndef _SELF_OPERATOR
#define _SELF_OPERATOR 1
using namespace std;
template <typename T> ostream &operator<<(ostream &cout, vector<T> vec) {
  cout << "{";
  for (int i = 0; i < (int)vec.size(); i++) {
    cout << vec[i];
    if (i != (int)vec.size() - 1)
      cout << ',';
  }
  cout << "}";
  return cout;
}

template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
  cout << "(" << p.first << ',' << p.second << ")";
  return cout;
}

template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
  vector<T> t;
  for (auto x : s)
    t.push_back(x);
  cout << t;
  return cout;
}

template <typename T> ostream &operator<<(ostream &cout, multiset<T> s) {
  vector<T> t;
  for (auto x : s)
    t.push_back(x);
  cout << t;
  return cout;
}

template <typename T> ostream &operator<<(ostream &cout, queue<T> q) {
  vector<T> t;
  while (q.size()) {
    t.push_back(q.front());
    q.pop();
  }
  cout << t;
  return cout;
}

template <typename T1, typename T2>
ostream &operator<<(ostream &cout, map<T1, T2> m) {
  for (auto &x : m) {
    cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
  }
  return cout;
}

template <typename T> T operator*(vector<T> v1, vector<T> v2) {
  assert(v1.size() == v2.size());
  int n = v1.size();
  T res = 0;
  for (int i = 0; i < n; i++) {
    res += v1[i] * v2[i];
  }
  return res;
}

template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> x, pair<T1, T2> y) {
  return make_pair(x.first + y.first, x.second + y.second);
}

template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, pair<T1, T2> y) {
  x.first += y.first;
  x.second += y.second;
}

template <typename T1, typename T2> pair<T1, T2> operator-(pair<T1, T2> x) {
  return make_pair(-x.first, -x.second);
}

template <typename T> vector<vector<T>> operator~(vector<vector<T>> vec) {
  vector<vector<T>> v;
  int n = vec.size(), m = vec[0].size();
  v.resize(m);
  for (int i = 0; i < m; i++) {
    v[i].resize(n);
  }
  for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
      v[i][j] = vec[j][i];
    }
  }
  return v;
}
#endif

void print0x(int x) {
  std::vector<int> vec;
  while (x) {
    vec.push_back(x & 1);
    x >>= 1;
  }
  std::reverse(vec.begin(), vec.end());
  for (int i = 0; i < (int)vec.size(); i++) {
    std::cout << vec[i];
  }
  std::cout << ' ';
}

template <typename T> void print0x(T x, int len) {
  std::vector<int> vec;
  while (x) {
    vec.push_back(x & 1);
    x >>= 1;
  }
  reverse(vec.begin(), vec.end());
  for (int i = vec.size(); i < len; i++) {
    putchar('0');
  }
  for (int i = 0; i < vec.size(); i++) {
    std::cout << vec[i];
  }
  std::cout << ' ';
}
#endif
struct DSU {
  int *f;
  int *depth;
  int *sz;
  inline void clear(int n) {
    for (int i = 0; i < n; i++) {
      f[i] = i;
      depth[i] = 1;
      sz[i] = 1;
    }
  }
  inline void init(int n) {
    f = new int[n + 5];
    depth = new int[n + 5];
    sz = new int[n + 5];
    clear(n);
  }
  inline int find(int x) { return (f[x] == x ? x : f[x] = find(f[x])); }
  inline int getSize(int x) { return sz[find(x)]; }
  inline void merge(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y)
      return;
    if (depth[x] > depth[y]) {
      f[y] = x;
      sz[x] += sz[y];
    } else if (depth[y] > depth[x]) {
      f[x] = y;
      sz[y] += sz[x];
    } else {
      sz[y] += sz[x];
      f[x] = y;
      depth[y]++;
    }
  }
};
using namespace std;

struct SegmentTreeMinChange //[)
{
  typedef pii T;
  const T maxValue = mp(inf, -1);
  const T minValue = mp(-inf, -1);
  T *dataMax;
  T *dataMin;
  T *tag;
  int nn;
  int size() { return nn; }
  void init(int size) {
    nn = 1;
    while (nn < size) {
      nn <<= 1;
    }
    dataMax = new T[nn * 2 + 5];
    dataMin = new T[nn * 2 + 5];
    for (int i = 0; i <= nn * 2; i++) {
      dataMin[i] = maxValue;
      dataMax[i] = minValue;
    }
  }
  void build(int a[], int len) {
    for (int i = 0; i < len; i++) {
      dataMax[i + nn] = mp(a[i], i);
      dataMin[i + nn] = mp(a[i], i);
    }
    for (int i = nn - 1; i >= 1; i--) {
      dataMin[i] = min(dataMin[i * 2], dataMin[i * 2 + 1]);
      dataMax[i] = max(dataMax[i * 2], dataMax[i * 2 + 1]);
    }
  }
  void erase(int pos) { erase(1, 0, nn, pos, pos + 1); }
  void erase(int x, int l, int r, int ql, int qr) {
    if (l >= qr || r <= ql)
      return;
    if (l >= ql && r <= qr) {
      dataMax[x] = minValue;
      dataMin[x] = maxValue;
      return;
    }
    erase(x * 2, l, l + r >> 1, ql, qr);
    erase(x * 2 + 1, l + r >> 1, r, ql, qr);
    dataMin[x] = min(dataMin[x * 2], dataMin[x * 2 + 1]);
    dataMax[x] = max(dataMax[x * 2], dataMax[x * 2 + 1]);
  }
  pair<T, T> query(int x, int l, int r, int ql, int qr) {
    if (r <= ql || l >= qr)
      return mp(maxValue, minValue);
    if (l >= ql && r <= qr) {
      return mp(dataMin[x], dataMax[x]);
    }
    pair<T, T> o1 = query(x * 2, l, l + r >> 1, ql, qr);
    pair<T, T> o2 = query(x * 2 + 1, l + r >> 1, r, ql, qr);
    return mp(min(o1.first, o2.first), max(o1.second, o2.second));
  }
  inline pair<T, T> query(int l, int r) { return query(1, 0, nn, l, r); }
} sgt;
DSU dsu;

int n;
int a[200005];
int b[200005];
vector<pair<pii, int>> vSort;
int dpa[200005];
int dpb[200005];
int ans[200005];
int h[200005];
int visit[200005];

void dfs(int x) {
  visit[x] = true;
  while (true) {
    pii mv = sgt.query(0, x).first;
    if (mv.first >= h[x])
      break;
    sgt.erase(mv.second);
    dsu.merge(mv.second, x);
    dfs(mv.second);
  }
  while (true) {
    pii mv = sgt.query(x + 1, n).second;
    if (mv.first <= h[x])
      break;
    sgt.erase(mv.second);
    dsu.merge(mv.second, x);
    dfs(mv.second);
  }
}

int main() {
  // freopen("input.txt","r",stdin);
  cin >> n;
  for (int i = 0; i < n; i++) {
    scanf("%d%d", a + i, b + i);
    a[i]--;
    b[i]--;
  }
  for (int i = 0; i < n; i++) {
    vSort.push_back(mp(mp(a[i], b[i]), i));
  }
  sort(all(vSort));
  for (int i = 0; i < n; i++) {
    h[i] = vSort[i].first.second;
  }
  dsu.init(n);
  sgt.init(n);
  sgt.build(h, n);

  for (int i = 0; i < n; i++) {
    if (!visit[i])
      dfs(i);
  }

  for (int i = 0; i < n; i++) {
    ans[vSort[i].second] = dsu.getSize(i);
  }
  for (int i = 0; i < n; i++) {
    printf("%d\\n", ans[i]);
  }
  return 0;
}


Error: 0

Fixed submission:

// Original Code:
// #include <self/utility>
// #include <self/debug>
// #include <self/dsu>
// using namespace std;
//
// struct SegmentTreeMinChange//[)
//{
//     typedef pii T;
//	const T maxValue=mp(inf,-1);
//     const T minValue=mp(-inf,-1);
//	T* dataMax;
//     T* dataMin;
//	T* tag;
//	int nn;
//	int size()
//	{
//		return nn;
//	}
//	void init(int size)
//	{
//		nn=1;
//		while(nn<size)
//		{
//			nn<<=1;
//		}
//		dataMax=new T[nn*2+5];
//         dataMin=new T[nn*2+5];
//		for(int i=0;i<=nn*2;i++)
//		{
//			dataMin[i]=maxValue;
//             dataMax[i]=minValue;
//		}
//	}
//	void build(int a[],int len)
//	{
//		for(int i=0;i<len;i++)
//		{
//			dataMax[i+nn]=mp(a[i],i);
//             dataMin[i+nn]=mp(a[i],i);
//		}
//		for(int i=nn-1;i>=1;i--)
//		{
//			dataMin[i]=min(dataMin[i*2],dataMin[i*2+1]);
//             dataMax[i]=max(dataMax[i*2],dataMax[i*2+1]);
//		}
//	}
//	void erase(int pos)
//	{
//		erase(1,0,nn,pos,pos+1);
//	}
//	void erase(int x,int l,int r,int ql,int qr)
//	{
//		if(l>=qr || r<=ql) return;
//		if(l>=ql && r<=qr)
//		{
//			dataMax[x]=minValue;
//             dataMin[x]=maxValue;
//			return;
//		}
//		erase(x*2,l,l+r>>1,ql,qr);
//		erase(x*2+1,l+r>>1,r,ql,qr);
//		dataMin[x]=min(dataMin[x*2],dataMin[x*2+1]);
//         dataMax[x]=max(dataMax[x*2],dataMax[x*2+1]);
//	}
//     pair <T,T> query(int x,int l,int r,int ql,int qr)
//     {
//         if(r<=ql || l>=qr) return mp(maxValue,minValue);
//         if(l>=ql && r<=qr)
//         {
//             return mp(dataMin[x],dataMax[x]);
//         }
//         pair<T,T> o1=query(x*2,l,l+r>>1,ql,qr);
//         pair<T,T> o2=query(x*2+1,l+r>>1,r,ql,qr);
//         return mp(min(o1.first,o2.first),max(o1.second,o2.second));
//     }
//     inline pair<T,T> query(int l,int r)
//     {
//         return query(1,0,nn,l,r);
//     }
// }sgt;
// DSU dsu;
//
// int n;
// int a[200005];
// int b[200005];
// vector <pair<pii,int> > vSort;
// int dpa[200005];
// int dpb[200005];
// int ans[200005];
// int h[200005];
//
// int main()
//{
//	freopen("input.txt","r",stdin);
//     cin>>n;
//     for(int i=0;i<n;i++)
//     {
//         scanf("%d%d",a+i,b+i);
//         a[i]--;
//         b[i]--;
//     }
//     for(int i=0;i<n;i++)
//     {
//         vSort.push_back(mp(mp(a[i],b[i]),i));
//     }
//     sort(all(vSort));
//     for(int i=0;i<n;i++)
//     {
//         h[i]=vSort[i].first.second;
//     }
//     dsu.init(n);
//     sgt.init(n);
//     sgt.build(h,n);
//     for(int i=0;i<n;i++)
//     {
//         while(true)
//         {
//             pii mv=sgt.query(0,i).first;
//             // cout<<mv.first<<' '<<h[i]<<endl;
//             if(mv.first>=h[i]) break;
//             // cout<<mv.second<<' '<<i<<endl;
//             sgt.erase(mv.second);
//             dsu.merge(mv.second,i);
//         }
//     }
//     for(int i=0;i<n;i++)
//     {
//         ans[vSort[i].second]=dsu.getSize(i);
//     }
//     for(int i=0;i<n;i++)
//     {
//         printf("%d\\n",ans[i]);
//     }
//	return 0;
// }

// substituted with C++ Inliner
#ifndef _SELF_UTILITY
#define _SELF_UTILITY 1
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
#define Endl endl
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define over(A)                                                                \\
  {                                                                            \\
    cout << A << endl;                                                         \\
    exit(0);                                                                   \\
  }
#define all(A) A.begin(), A.end()
#define quickcin ios_base::sync_with_stdio(false);
const int mod = 998244353;
const int gmod = 2;
const int inf = 1039074182;
const ll llinf = 1LL * inf * inf;
template <typename T1, typename T2> inline void chmin(T1 &x, T2 b) {
  if (b < x)
    x = b;
}
template <typename T1, typename T2> inline void chmax(T1 &x, T2 b) {
  if (b > x)
    x = b;
}
template <typename T1, typename T2> inline void chadd(T1 &x, T2 b) {
  x += b;
  if (x >= mod)
    x -= mod;
}
template <typename T1, typename T2> inline void chmul(T1 &x, T2 b) {
  x = 1LL * x * b % mod;
}
template <typename T1, typename T2> inline void chmod(T1 &x, T2 b) {
  x %= b, x += b;
  if (x >= b)
    x -= b;
}
#endif

#ifndef _SELF_DEBUG
#define _SELF_DEBUG 1
#ifndef _SELF_OPERATOR
#define _SELF_OPERATOR 1
using namespace std;
template <typename T> ostream &operator<<(ostream &cout, vector<T> vec) {
  cout << "{";
  for (int i = 0; i < (int)vec.size(); i++) {
    cout << vec[i];
    if (i != (int)vec.size() - 1)
      cout << ',';
  }
  cout << "}";
  return cout;
}

template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
  cout << "(" << p.first << ',' << p.second << ")";
  return cout;
}

template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
  vector<T> t;
  for (auto x : s)
    t.push_back(x);
  cout << t;
  return cout;
}

template <typename T> ostream &operator<<(ostream &cout, multiset<T> s) {
  vector<T> t;
  for (auto x : s)
    t.push_back(x);
  cout << t;
  return cout;
}

template <typename T> ostream &operator<<(ostream &cout, queue<T> q) {
  vector<T> t;
  while (q.size()) {
    t.push_back(q.front());
    q.pop();
  }
  cout << t;
  return cout;
}

template <typename T1, typename T2>
ostream &operator<<(ostream &cout, map<T1, T2> m) {
  for (auto &x : m) {
    cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
  }
  return cout;
}

template <typename T> T operator*(vector<T> v1, vector<T> v2) {
  assert(v1.size() == v2.size());
  int n = v1.size();
  T res = 0;
  for (int i = 0; i < n; i++) {
    res += v1[i] * v2[i];
  }
  return res;
}

template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> x, pair<T1, T2> y) {
  return make_pair(x.first + y.first, x.second + y.second);
}

template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, pair<T1, T2> y) {
  x.first += y.first;
  x.second += y.second;
}

template <typename T1, typename T2> pair<T1, T2> operator-(pair<T1, T2> x) {
  return make_pair(-x.first, -x.second);
}

template <typename T> vector<vector<T>> operator~(vector<vector<T>> vec) {
  vector<vector<T>> v;
  int n = vec.size(), m = vec[0].size();
  v.resize(m);
  for (int i = 0; i < m; i++) {
    v[i].resize(n);
  }
  for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
      v[i][j] = vec[j][i];
    }
  }
  return v;
}
#endif

void print0x(int x) {
  std::vector<int> vec;
  while (x) {
    vec.push_back(x & 1);
    x >>= 1;
  }
  std::reverse(vec.begin(), vec.end());
  for (int i = 0; i < (int)vec.size(); i++) {
    std::cout << vec[i];
  }
  std::cout << ' ';
}

template <typename T> void print0x(T x, int len) {
  std::vector<int> vec;
  while (x) {
    vec.push_back(x & 1);
    x >>= 1;
  }
  reverse(vec.begin(), vec.end());
  for (int i = vec.size(); i < len; i++) {
    putchar('0');
  }
  for (int i = 0; i < vec.size(); i++) {
    std::cout << vec[i];
  }
  std::cout << ' ';
}
#endif
struct DSU {
  int *f;
  int *depth;
  int *sz;
  inline void clear(int n) {
    for (int i = 0; i < n; i++) {
      f[i] = i;
      depth[i] = 1;
      sz[i] = 1;
    }
  }
  inline int init(int n) {
    f = new int[n + 5];
    depth = new int[n + 5];
    sz = new int[n + 5];
    clear(n);
  }
  inline int find(int x) { return (f[x] == x ? x : f[x] = find(f[x])); }
  inline int getSize(int x) { return sz[find(x)]; }
  inline void merge(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y)
      return;
    if (depth[x] > depth[y]) {
      f[y] = x;
      sz[x] += sz[y];
    } else if (depth[y] > depth[x]) {
      f[x] = y;
      sz[y] += sz[x];
    } else {
      sz[y] += sz[x];
      f[x] = y;
      depth[y]++;
    }
  }
};
using namespace std;

struct SegmentTreeMinChange //[)
{
  typedef pii T;
  const T maxValue = mp(inf, -1);
  const T minValue = mp(-inf, -1);
  T *dataMax;
  T *dataMin;
  T *tag;
  int nn;
  int size() { return nn; }
  void init(int size) {
    nn = 1;
    while (nn < size) {
      nn <<= 1;
    }
    dataMax = new T[nn * 2 + 5];
    dataMin = new T[nn * 2 + 5];
    for (int i = 0; i <= nn * 2; i++) {
      dataMin[i] = maxValue;
      dataMax[i] = minValue;
    }
  }
  void build(int a[], int len) {
    for (int i = 0; i < len; i++) {
      dataMax[i + nn] = mp(a[i], i);
      dataMin[i + nn] = mp(a[i], i);
    }
    for (int i = nn - 1; i >= 1; i--) {
      dataMin[i] = min(dataMin[i * 2], dataMin[i * 2 + 1]);
      dataMax[i] = max(dataMax[i * 2], dataMax[i * 2 + 1]);
    }
  }
  void erase(int pos) { erase(1, 0, nn, pos, pos + 1); }
  void erase(int x, int l, int r, int ql, int qr) {
    if (l >= qr || r <= ql)
      return;
    if (l >= ql && r <= qr) {
      dataMax[x] = minValue;
      dataMin[x] = maxValue;
      return;
    }
    erase(x * 2, l, l + r >> 1, ql, qr);
    erase(x * 2 + 1, l + r >> 1, r, ql, qr);
    dataMin[x] = min(dataMin[x * 2], dataMin[x * 2 + 1]);
    dataMax[x] = max(dataMax[x * 2], dataMax[x * 2 + 1]);
  }
  pair<T, T> query(int x, int l, int r, int ql, int qr) {
    if (r <= ql || l >= qr)
      return mp(maxValue, minValue);
    if (l >= ql && r <= qr) {
      return mp(dataMin[x], dataMax[x]);
    }
    pair<T, T> o1 = query(x * 2, l, l + r >> 1, ql, qr);
    pair<T, T> o2 = query(x * 2 + 1, l + r >> 1, r, ql, qr);
    return mp(min(o1.first, o2.first), max(o1.second, o2.second));
  }
  inline pair<T, T> query(int l, int r) { return query(1, 0, nn, l, r); }
} sgt;
DSU dsu;

int n;
int a[200005];
int b[200005];
vector<pair<pii, int>> vSort;
int dpa[200005];
int dpb[200005];
int ans[200005];
int h[200005];

int main() {
  //	freopen("input.txt","r",stdin);
  cin >> n;
  for (int i = 0; i < n; i++) {
    scanf("%d%d", a + i, b + i);
    a[i]--;
    b[i]--;
  }
  for (int i = 0; i < n; i++) {
    vSort.push_back(mp(mp(a[i], b[i]), i));
  }
  sort(all(vSort));
  for (int i = 0; i < n; i++) {
    h[i] = vSort[i].first.second;
  }
  dsu.init(n);
  sgt.init(n);
  sgt.build(h, n);
  for (int i = 0; i < n; i++) {
    while (true) {
      pii mv = sgt.query(0, i).first;
      // cout<<mv.first<<' '<<h[i]<<endl;
      if (mv.first >= h[i])
        break;
      // cout<<mv.second<<' '<<i<<endl;
      sgt.erase(mv.second);
      dsu.merge(mv.second, i);
    }
  }
  for (int i = 0; i < n; i++) {
    ans[vSort[i].second] = dsu.getSize(i);
  }
  for (int i = 0; i < n; i++) {
    printf("%d\\n", ans[i]);
  }
  return 0;
}