D - 買い物上手 https://atcoder.jp/contests/arc031/tasks/arc031_4

arc031_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"))


def binary_search(ok, ng):
    while abs(ok - ng) > 10**-9:
        mid = (ok + ng) / 2
        if chk(mid):
            ok = mid
        else:
            ng = mid
    return ok


def chk(x):
    g = Dinic(N + M + 2)
    for i in range(N):          # Source -> 経験値
        g.add_edge(0, i + 1, S[i])
    for i in range(N):          # 経験値 -> アイテム
        for j in range(len(A[i])):
            g.add_edge(i + 1, N + A[i][j], float("inf"))
    for i in range(M):          # アイテム -> Sink
        g.add_edge(i + N + 1, N + M + 1, T[i] * x)
    f = g.max_flow(0, N + M + 1)
    return sum(S) <= f


N, M = map(int, input().split())
S = list(map(int, input().split()))
T = list(map(int, input().split()))
A = []
for _ in range(N):
    k, *a = list(map(int, input().split()))
    A.append(a)
print(binary_search(10**9, 0))