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


def dfs (graph, used, from, sink, flow)
  return flow if from == sink
  used[from] = true
  
  graph[from].each{|edge|
    next if used[edge[0]] || (edge[1]<=0)
    
    fmin = edge[1]
    fmin = flow if fmin > flow
    
    d = dfs(graph, used, edge[0], sink, fmin)
    
    if d > 0 then
      edge[1] -= d
      graph[edge[0]][edge[2]][1] += d
      return d
    end
  }
  return 0
end

def addedge graph,from,to
  cap = 1
  graph[from]<<[to,cap,graph[to].size]
  graph[to]<<[from,0,graph[from].size-1]
end

n = gets.to_i
red = n.times.map{gets.split.map &:to_i}
blue = n.times.map{gets.split.map &:to_i}

s = n*2
t = s+1
inf = 100000000

graph = (n*2+2).times.map{[]}
used = Array.new(n*2+2, false)

n.times{|i|
  addedge(graph,s,i)
}
n.times{|i|
  addedge(graph,n+i,t)
}

red.each.with_index{|(x1,y1),i|
  blue.each.with_index{|(x2,y2),j|
    if x1<x2 && y1<y2
      addedge(graph,i,n+j)
    end
  }
}


flow = 0
while 1
  (n*2+2).times{|i| used[i]=false}
  f = dfs(graph, used, s, t, inf)
  break if f==0
  flow += f
end

p flow