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

use std::str::FromStr;
use std::io::*;
use std::cmp::*;
use utils::*;

pub fn main() {
    let i = stdin();
    let mut o = Vec::new();
    run(i.lock(), &mut o);
    stdout().write_all(&o).unwrap();
}

fn run<R: BufRead, W: Write>(i: R, o: &mut W) {
    let mut i = AtRead::from(i);
    let n = i.read::<usize>();
    let mut reds = Vec::new();
    let mut blues = Vec::new();

    for _ in 0..n {
        reds.push(i.read2::<usize, usize>());
    }
    for _ in 0..n {
        blues.push(i.read2::<usize, usize>());
    }
    writeln!(o, "{}", solve(n, reds, blues)).unwrap();
}
fn solve(n: usize, mut reds: Vec<(usize, usize)>, mut blues: Vec<(usize, usize)>) -> usize {
    fn can_pair(r: (usize, usize), b: (usize, usize)) -> bool {
        r.0 < b.0 && r.1 < b.1
    };

    blues.sort();
    for &b in &blues {
        if let Some(i) = reds.iter()
            .enumerate()
            .filter(|&(_, &xy)| can_pair(xy, b))
            .max_by_key(|&(_, &(_, y))| y)
            .map(|(i, _)| i)
        {
            reds.remove(i);
        }
    }
    n - reds.len()
}
fn solve_old(n: usize, reds: Vec<(usize, usize)>, blues: Vec<(usize, usize)>) -> usize {
    let can_pair = |n_red: usize, n_blue: usize| {
        let red = reds[n_red];
        let blue = blues[n_blue];
        red.0 < blue.0 && red.1 < blue.1
    };
    let mut cp_red = vec![0usize; n];
    let mut cp_blue = vec![0usize; n];

    for n_red in 0..n {
        for n_blue in 0..n {
            if can_pair(n_red, n_blue) {
                cp_red[n_red] += 1;
                cp_blue[n_blue] += 1;
            }
        }
    }
    let mut r = 0;
    loop {
        let min_red = cp_red
            .iter()
            .cloned()
            .enumerate()
            .filter(|&x| x.1 != 0)
            .min_by_key(|&x| x.1);
        let min_blue = cp_blue
            .iter()
            .cloned()
            .enumerate()
            .filter(|&x| x.1 != 0)
            .min_by_key(|&x| x.1);
        if let (Some((mut n_red, c_red)), Some((mut n_blue, c_blue))) = (min_red, min_blue) {
            if c_red < c_blue {
                n_blue = (0..n)
                    .filter(|&n_blue| can_pair(n_red, n_blue) && cp_blue[n_blue] != 0)
                    .min_by_key(|&n_blue| cp_blue[n_blue])
                    .unwrap();
            } else {
                n_red = (0..n)
                    .filter(|&n_red| can_pair(n_red, n_blue) && cp_red[n_red] != 0)
                    .min_by_key(|&n_red| cp_red[n_red])
                    .unwrap();
            }

            r += 1;
            for n_red in 0..n {
                if can_pair(n_red, n_blue) && cp_red[n_red] != 0 {
                    cp_red[n_red] -= 1;
                }
            }
            for n_blue in 0..n {
                if can_pair(n_red, n_blue) && cp_blue[n_blue] != 0 {
                    cp_blue[n_blue] -= 1;
                }
            }
            cp_red[n_red] = 0;
            cp_blue[n_blue] = 0;
        } else {
            break;
        }
    }
    r
}

mod utils {
    use super::*;
    use std::ops::*;

    pub struct AtRead<R: BufRead> {
        r: R,
        s: String,
    }

    macro_rules! fn_read {
        {$f:ident($($v:ident: $t:ident),*)} => {
            pub fn $f<$($t: FromStr),*>(&mut self) -> ($($t),*) {
                let i = &mut self.read_line().split(' ');
                $(
                    let $v = next(i);
                )*
                ($($v),*)
            }
        };
    }

    impl<R: BufRead> AtRead<R> {
        pub fn from(r: R) -> Self {
            AtRead {
                r: r,
                s: String::new(),
            }
        }
        pub fn read_line(&mut self) -> &str {
            self.s.clear();
            self.r.read_line(&mut self.s).unwrap();
            self.s.trim()
        }

        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_line().parse().ok().unwrap()
        }
        fn_read! { read2(v1: T1, v2: T2) }
    }

    fn next<'a, T: FromStr, I: std::iter::Iterator<Item = &'a str>>(i: &mut I) -> T {
        i.next().unwrap().parse().ok().unwrap()
    }

}