Problem:
Score : 300 points

Problem Statement

There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).

For each k = 1,2,\dots,N, find the answer to the following question:

Rng is in City k.
Rng can perform the following move arbitrarily many times:

move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.

How many cities (including City k) are reachable from City k?

Constraints

1 \leq N \leq 200,000

(x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).

(y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_N y_N

Output

Print N lines. In i-th line print the answer to the question when k = i.

Sample Input 1

4
1 4
2 3
3 1
4 2

Sample Output 1

1
1
2
2

Rng can reach City 4 from City 3, or conversely City 3 from City 4.

Sample Input 2

7
6 4
4 3
3 5
7 1
2 7
5 2
1 6

Sample Output 2

3
3
1
1
2
3
2

Solution in C++ (GCC 9.2.1 with AC Library v1.1) (judge verdict: Accepted)

#include <algorithm>
#include <atcoder/all>
#include <iostream>
#include <set>
#include <tuple>
#include <vector>

using ll = long long;
#define rep(i, j, n) for (int i = j; i < (n); ++i)
using namespace std;
using namespace atcoder;

int main() {
  int n;
  cin >> n;
  vector<tuple<int, int, int>> xy, yx;

  for (int i = 0; i < n; ++i) {

    int x, y;
    cin >> x >> y;
    xy.emplace_back(x - 1, y - 1, i);
    yx.emplace_back(y - 1, x - 1, i);
  }
  sort(xy.begin(), xy.end());
  sort(yx.begin(), yx.end());
  dsu uf(n);
  set<int> st;
  rep(i, 0, n) st.insert(i); // まだ使ってないyの値

  int x1, y1, v1, x2, y2, v2;
  for (int i = 0; i < n; ++i) {
    tie(x1, y1, v1) = xy[i];
    if (y1 < *st.rbegin()) {
      int j = i + 1;
      while (j < n) {
        tie(x2, y2, v2) = xy[j];
        uf.merge(v1, v2);
        if (y1 < y2) { break; }
        st.erase(st.find(y2));
        ++j;
      }
      st.erase(st.find(y1));
      i = j - 1;
    } else
      st.erase(st.find(y1));
  }

  st.clear();
  rep(i, 0, n) st.insert(i);

  for (int i = 0; i < n; ++i) {
    tie(x1, y1, v1) = yx[i];
    if (y1 < *st.rbegin()) {
      int j = i + 1;
      while (j < n) {
        tie(x2, y2, v2) = yx[j];
        uf.merge(v1, v2);
        if (y1 < y2) { break; }
        st.erase(st.find(y2));
        ++j;
      }
      st.erase(st.find(y1));
      i = j - 1;
    } else
      st.erase(st.find(y1));
  }

  reverse(xy.begin(), xy.end());
  reverse(yx.begin(), yx.end());

  st.clear();
  rep(i, 0, n) st.insert(i);

  for (int i = 0; i < n; ++i) {
    tie(x1, y1, v1) = xy[i];
    if (y1 > *st.begin()) {
      int j = i + 1;
      while (j < n) {
        tie(x2, y2, v2) = xy[j];
        uf.merge(v1, v2);
        if (y1 > y2) { break; }
        st.erase(st.find(y2));
        ++j;
      }
      st.erase(st.find(y1));
      i = j - 1;
    } else
      st.erase(st.find(y1));
  }

  st.clear();
  rep(i, 0, n) st.insert(i);

  for (int i = 0; i < n; ++i) {
    tie(x1, y1, v1) = yx[i];
    if (y1 > *st.begin()) {
      int j = i + 1;
      while (j < n) {
        tie(x2, y2, v2) = yx[j];
        uf.merge(v1, v2);
        if (y1 > y2) { break; }
        st.erase(st.find(y2));
        ++j;
      }
      st.erase(st.find(y1));
      i = j - 1;
    } else
      st.erase(st.find(y1));
  }

  for (int i = 0; i < n; ++i) cout << uf.size(i) << '\n';

  return 0;
}