D - 浮気予防 https://atcoder.jp/contests/abc010/tasks/abc010_4

abc010_4.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, G, E = map(int, input().split())
p = list(map(int, input().split()))
g = Dinic(N + 1)
for _ in range(E):
    a, b = map(int, input().split())
    g.add_edge(a, b, 1)
    g.add_edge(b, a, 1)
for i in p:
    g.add_edge(i, N, 1)
print(g.max_flow(0, N))