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) (judge verdict: Accepted)

#include <bits/stdc++.h>
#define f first
#define s second
#define MOD 1000000007
#define PMOD 998244353
#define pb(x) push_back(x)
using namespace std;

typedef long long int ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> plii;
typedef pair<int, pii> piii;
const int INF = 1e9+10;
const ll LINF = 1LL*INF*INF;
const int MAXN = 2e5+10;
const int MAXM = 5e3+10;

priority_queue<int> pq;
vector<vector<int> > graph;
queue<int> que;

int A[MAXN];
int B[MAXN];
int ii[MAXN];
int id[MAXN];
int ans[MAXN];
int tree[MAXN*4];

void update(int tmp,int v)
{
    tree[tmp] = v;
    tmp>>=1;

    while(tmp){
        tree[tmp] = min(tree[tmp<<1],tree[(tmp<<1)|1]);
        tmp>>=1;
    }

    return;
}

int getans(int L,int R)
{
    int res = INF;

    while(L<=R){
        if(L&1){
            res = min(res,tree[L]);
            L++;
        }
        if(!(R&1)){
            res = min(res,tree[R]);
            R--;
        }
        L>>=1; R>>=1;
    }

    return res;
}

int par[MAXN];
int rnk[MAXN];

int root(int x)
{
    if(x==par[x])return x;
    return par[x] = root(par[x]);
}

bool mymerge(int x,int y)
{
    x = root(x);
    y = root(y);

    if(x==y)return false;

    par[y] = x;
    rnk[x]+=rnk[y];

    return true;
}


int main()
{
    int n,m,k,a,b,x,y,q;
    int sum = 0;
    int cnt = 0;
    int mx = 0;
    int mn = INF;
    int cur = 0, idx = -1;
    int tc;

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    cin>>n;

    for(int i=1;i<=n;i++){
        cin>>A[i]>>B[i];
    }

    if(n==1){
        cout<<1<<"\n";
        return 0;
    }

    for(int i=1;i<=n;i++){
        id[A[i]] = B[i];
        ii[B[i]] = A[i];
        par[i] = i;
        rnk[i] = 1;
    }

    int pre = 0;

    vector<pii> val;

    id[0] = INF;

    for(int i=1;i<n;i++){
        if(id[i]>id[i+1]){
            val.push_back(pii(pre+1,i));
            pre = i;
        }
        else {
            mymerge(i,i+1);
        }
    }

    val.push_back(pii(pre+1,n));

    a = b = 0;

    int base = 1;

    for(;base<n;base<<=1);

    for(int i=1;i<(base<<1);i++)tree[i] = INF;

    for(int i=0;i<(int)val.size();i++){

        x = val[i].f;
        y = val[i].s;

        mn = id[x];

        while(true){

            cur = getans(base,base+id[y]-1);

            if(cur==INF)break;

            mn = min(mn,cur);

            mymerge(ii[cur],y);

            update(base+cur-1,INF);
        }

        update(base+mn-1,mn);
    }

    for(int i=1;i<=n;i++){
        cur = A[i];
        cur = root(cur);
        cout<<rnk[cur]<<"\n";
    }


    return 0;
}