Problem:
Score : 400 points

Problem Statement

On a two-dimensional plane, there are N red points and N blue points.
The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).

A red point and a blue point can form a friendly pair when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.

At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.

Constraints

All input values are integers.

1 \leq N \leq 100

0 \leq a_i, b_i, c_i, d_i < 2N

a_1, a_2, ..., a_N, c_1, c_2, ..., c_N are all different.

b_1, b_2, ..., b_N, d_1, d_2, ..., d_N are all different.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
a_2 b_2
:
a_N b_N
c_1 d_1
c_2 d_2
:
c_N d_N

Output

Print the maximum number of friendly pairs.

Sample Input 1

3
2 0
3 1
1 3
4 2
0 4
5 5

Sample Output 1

2

For example, you can pair (2, 0) and (4, 2), then (3, 1) and (5, 5).

Sample Input 2

3
0 0
1 1
5 2
2 3
3 4
4 5

Sample Output 2

2

For example, you can pair (0, 0) and (2, 3), then (1, 1) and (3, 4).

Sample Input 3

2
2 2
3 3
0 0
1 1

Sample Output 3

0

It is possible that no pair can be formed.

Sample Input 4

5
0 0
7 3
2 2
4 8
1 6
8 5
6 9
5 4
9 1
3 7

Sample Output 4

5

Sample Input 5

5
0 0
1 1
5 5
6 6
7 7
2 2
3 3
4 4
8 8
9 9

Sample Output 5

4

Solution in JavaScript (Node.js 12.16.1) (judge verdict: Runtime Error)

function Main(input) {
	input = input.trim().split("\n").map(function(x) { return x.split(" ")});
	var N = parseInt(input[0][0], 10);
	var arr_ab = [];
	var arr_cd = [];
	for (var i = 0; i < N; i++){
		arr_ab.push(input[i + 1].map(e => parseInt(e, 10)));
		arr_cd.push(input[i + N + 1].map(e => parseInt(e, 10)));
	}
	var arr_redConnection = Array.from({length: N}, ()=> []);
	var arr_blueConnection = Array.from({length: N}, ()=> []);
	var arr_redConnectionCount = Array.from({length: N}, ()=> 0);
	var arr_blueConnectionCount = Array.from({length: N}, ()=> 0);
	var remainedPaths = 0;
	for (var i = 0; i < N; i++){
		for (var j = 0; j < N; j++){
			if (arr_ab[i][0] < arr_cd[j][0] && arr_ab[i][1] < arr_cd[j][1]) {
			arr_redConnection[i].push(j);
			arr_redConnectionCount[i] ++;
			arr_blueConnection[j].push(i);
			arr_blueConnectionCount[j] ++;
			remainedPaths ++;
			}
		}
	}

	var tmp;
	var whichIsChosen = [-1, -1];
	var ans = 0; 
	var exclude = [Array.from({length: N}, ()=> 0), Array.from({length: N}, ()=> 0)];
	while (remainedPaths > 0){
		tmp = 2 * N;
		for (var i = 0; i < arr_redConnection.length ; i++){
			if (exclude[0][i] === 1) continue;
			for (var j of arr_redConnection[i]){
				if (exclude[1][j] === 1) continue;
				if ((arr_redConnectionCount[i] + arr_blueConnectionCount[j]) < tmp){
					tmp = arr_redConnectionCount[i] + arr_blueConnectionCount[j];
					whichIsChosen[0] = i;
					whichIsChosen[1] = j;
				}
			}
		}
		remainedPaths -= (tmp - 1);
		ans ++;
		for (var i of arr_redConnection[whichIsChosen[0]]){
			arr_blueConnection[i] = arr_blueConnection[i].filter(n => n !== whichIsChosen[0]);
			arr_blueConnectionCount[i] --;
		}
		for (var i of arr_blueConnection[whichIsChosen[1]]){
			arr_redConnection[i] = arr_redConnection[i].filter(n => n !== whichIsChosen[1]);
			arr_redConnectionCount[i] --;
		}
		exclude[0][whichIsChosen[0]] = 1;
		exclude[1][whichIsChosen[1]] = 1;
		arr_redConnection[whichIsChosen[0]] = whichIsChosen[1];
		arr_redConnectionCount[whichIsChosen[0]] = 1;
		arr_blueConnection[whichIsChosen[1]] = whichIsChosen[0];
		arr_blueConnectionCount[whichIsChosen[1]] = 1;
	}
	console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));