F - Grid and Tokens https://atcoder.jp/contests/abc205/tasks/abc205_f

abc205_f.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"))


H, W, N = map(int, input().split())
SIZE = H + W + 2 * N + 2
g = Dinic(SIZE)
layer = [H, H + N, H + 2 * N, H + 2 * N + W]
source, sink = 0, SIZE - 1
for i in range(layer[0]):  # Source -> Row
    g.add_edge(source, i + 1, 1)
for i in range(layer[2], layer[3]):  # Column -> Sink
    g.add_edge(i + 1, sink, 1)
for i in range(N):  # U -> V
    g.add_edge(layer[0] + i + 1, layer[0] + i + 1 + N, 1)
for i in range(N):
    a, b, c, d = map(int, input().split())
    for j in range(a, c + 1):  # R -> U
        g.add_edge(j, layer[0] + i + 1, 1)
    for j in range(b, d + 1):  # V -> C
        g.add_edge(layer[1] + i + 1, layer[2] + j, 1)
print(g.max_flow(source, sink))