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 <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <iterator>
#include <cmath>
#include <set>
#include <deque> 
#include <string>


using namespace std;

struct Point {
	long long x, y;
	int count;
	int pos;
};

Point pts[200010];
int n;

bool compare(Point &a, Point &b) {
	return a.x < b.x;
}

bool comparePos(Point &a, Point &b) {
	return a.pos < b.pos;
}

bool isUsed[200010];

int main()
{
	scanf("%d", &n);
	for (int i = 0 ; i < n ; i++) {
		scanf("%lld%lld", &(pts[i].x), &(pts[i].y));
		pts[i].count = 0;
		pts[i].pos = i;
	}
	
	sort(pts, pts + n, compare);
	memset(isUsed, false, sizeof(isUsed));
	
	int minY;
	int maxY = n;
	int l = 0;
	int h = 0;
	int sz;
	while (l < n) {
		h = l;
		minY = pts[l].y;
		
		while (h < n) {
			if (pts[h].y < minY) {
				minY = pts[h].y;
			}
			
			if (pts[h].y >= maxY) {
				break;
			}
			h++;
		}
		
		sz = h - l + 1;
		int dist = (maxY - minY) + 1;
		while (dist > sz) {
			h++;
			sz++;
			if (pts[h].y < minY) {
				minY = pts[h].y;
			}
			dist = (maxY - minY) + 1;
		}
		
		
		if (h >= n) {
			h--;
		}
		
		
		
		for (int p = l ; p <= h ; p++) {
			pts[p].count = sz;
			isUsed[pts[p].y] = true;
		}
		
		while (isUsed[maxY] == true) {
			maxY--;
		}
		
		l = h + 1;
	}
	
	sort(pts, pts + n, comparePos);
	
	for (int i = 0 ; i < n ; i++) {
		printf("%d\n", pts[i].count);
	}
	

	return 0;
}