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 Java (OpenJDK 1.8.0) (judge verdict: Runtime Error)

import java.io.*; import java.util.*;
public class Main {

    public static class Pair {
        int y; int ind;
        public Pair(int b, int c){
            this.y=b; this.ind=c;
        }
        
    }
    static int N;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        N=Integer.parseInt(br.readLine());
        Pair[] pr=new Pair[N];
        Pair[] pr2=new Pair[N];
        for (int i = 0; i < N; i++) {
            StringTokenizer st=new StringTokenizer(br.readLine());
            int a=Integer.parseInt(st.nextToken())-1;
            int b=Integer.parseInt(st.nextToken())-1;
            pr[a]=new Pair(b,i); pr2[b]=new Pair(a,i);
        }
        int[] rank=new int[N];
        int[] par=new int[N]; int[] siz=new int[N];
        for (int i = 0; i < N; i++) {
            par[i]=i; siz[i]++;
        }
        int k,l; boolean[] done=new boolean[N];       
        boolean[] ydone=new boolean[N];
        int pter=N-1;
        for (int i = 0; i < N; i++) {//Increasing order of x-coordinate
            //y[i] is known
            if(done[i])continue;
            if(pr[i].y==pter){
                ydone[pter]=true;
                while(ydone[pter]){
                    pter--;
                }
                continue;
            }
            for (int j = pr[i].y+1; j < N; j++) {
                //merge pr[i].ind and pr2[j].ind
                if(pr2[j].y>i){
                    done[pr2[j].y]=true;
                    k=find(pr[i].ind,par); l=find(pr2[j].ind,par);
                    if(k!=l){
                        if(rank[k]>rank[l]){
                            par[l]=k; siz[k]+=siz[l];
                        }else if(rank[k]==rank[l]){
                            rank[l]++; par[k]=l; siz[l]+=siz[k];
                        }else{
                            par[k]=l; siz[l]+=siz[k];
                        }
                    }
                }
                
                
            }
        }
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < N; i++) {
            sb.append(siz[find(i,par)]).append("\n");
        }
        System.out.println(sb.toString());
    }
    public static int find(int x, int[] p){
        if(p[x]==x)return x;
        int ans=find(p[x],p); p[x]=ans; return ans;
    }
}