C - 2D Plane 2N Points https://atcoder.jp/contests/abc091/tasks/arc092_a

arc092_a2.py

from collections import deque


class Dinic:
    def __init__(self, max_v):
        self.n = max_v
        self.G = [[] for _ in range(self.n)]

    def add_edge(self, fr, to, cap):  # frからtoへ向かう容量capの辺を追加する
        self.G[fr].append([to, cap, len(self.G[to])])
        self.G[to].append([fr, 0, len(self.G[fr]) - 1])

    def bfs(self, s):  # sからの最短距離をBFSで計算する
        self.level = [-1 for _ in range(self.n)]  # sからの距離
        que = deque()
        self.level[s] = 0
        que.append(s)
        while que:
            v = que.popleft()
            for i in range(len(self.G[v])):
                e = self.G[v][i]
                if e[1] > 0 and self.level[e[0]] < 0:
                    self.level[e[0]] = self.level[v] + 1
                    que.append(e[0])

    def dfs(self, v, t, f):  # 増加パスをDFSで探す
        if v == t:
            return f
        for i in range(self.iter[v], len(self.G[v])):
            self.iter[v] = i
            e = self.G[v][i]
            if e[1] > 0 and self.level[v] < self.level[e[0]]:
                d = self.dfs(e[0], t, min(f, e[1]))
                if d > 0:
                    e[1] -= d
                    self.G[e[0]][e[2]][1] += d
                    return d
        return 0

    def max_flow(self, s, t):
        flow = 0
        while True:
            self.bfs(s)
            if self.level[t] < 0:
                return flow
            self.iter = [0 for _ in range(self.n)]  # どこまで調べ終わったか
            f = self.dfs(s, t, float("inf"))
            while f > 0:
                flow += f
                f = self.dfs(s, t, float("inf"))


N = int(input())
red = [list(map(int, input().split())) for _ in range(N)]
blue = [list(map(int, input().split())) for _ in range(N)]
g = Dinic(2 * N + 2)
for i in range(N):  # Source -> 赤い点
    g.add_edge(0, i + 1, 1)
for i in range(N):  # 赤い点 -> 青い点
    for j in range(N):
        if red[i][0] < blue[j][0] and red[i][1] < blue[j][1]:
            g.add_edge(i + 1, N + j + 1, 1)
for i in range(N):  # 青い点 -> Sink
    g.add_edge(N + i + 1, 2 * N + 1, 1)
print(g.max_flow(0, 2 * N + 1))