結果

問題 No.2328 Build Walls
コンテスト
ユーザー lam6er
提出日時 2025-04-16 16:35:32
言語 PyPy3
(7.3.15)
結果
MLE  
実行時間 -
コード長 3,055 bytes
コンパイル時間 279 ms
コンパイル使用メモリ 81,776 KB
実行使用メモリ 570,088 KB
最終ジャッジ日時 2025-04-16 16:38:46
合計ジャッジ時間 5,893 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge1
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 10 MLE * 1 -- * 23
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
from collections import deque

class Edge:
    def __init__(self, to, rev, cap):
        self.to = to
        self.rev = rev
        self.cap = cap

def main():
    INF = 1 << 60
    H, W = map(int, sys.stdin.readline().split())
    A = []
    for _ in range(H-2):
        row = list(map(int, sys.stdin.readline().split()))
        A.append(row)
    
    total_nodes = 2 * H * W + 2
    S = 2 * H * W
    T = S + 1
    graph = [[] for _ in range(total_nodes)]
    
    def add_edge(fr, to, cap):
        forward = Edge(to, len(graph[to]), cap)
        backward = Edge(fr, len(graph[fr]), 0)
        graph[fr].append(forward)
        graph[to].append(backward)
    
    for i in range(1, H+1):
        for j in range(1, W+1):
            in_node = (i-1)*W + (j-1)
            out_node = in_node + H * W
            if i == 1 or i == H:
                add_edge(in_node, out_node, INF)
            else:
                a = A[i-2][j-1]
                if a == -1:
                    add_edge(in_node, out_node, INF)
                else:
                    add_edge(in_node, out_node, a)
            dirs = [(-1,0), (1,0), (0,-1), (0,1)]
            for di, dj in dirs:
                ni = i + di
                nj = j + dj
                if 1 <= ni <= H and 1 <= nj <= W:
                    adj_in = (ni-1)*W + (nj-1)
                    add_edge(out_node, adj_in, INF)
    
    for j in range(1, W+1):
        in_node = (1-1)*W + (j-1)
        add_edge(S, in_node, INF)
    
    for j in range(1, W+1):
        out_node = (H-1)*W + (j-1) + H * W
        add_edge(out_node, T, INF)
    
    level = [0] * total_nodes
    ptr = [0] * total_nodes
    
    def bfs(s, t):
        q = deque()
        level[:] = [-1] * total_nodes
        level[s] = 0
        q.append(s)
        while q:
            v = q.popleft()
            for edge in graph[v]:
                if edge.cap > 0 and level[edge.to] == -1:
                    level[edge.to] = level[v] + 1
                    q.append(edge.to)
                    if edge.to == t:
                        return True
        return False
    
    def dfs(v, t, flow):
        if v == t:
            return flow
        while ptr[v] < len(graph[v]):
            edge = graph[v][ptr[v]]
            if edge.cap > 0 and level[v] < level[edge.to]:
                min_flow = min(flow, edge.cap)
                pushed = dfs(edge.to, t, min_flow)
                if pushed > 0:
                    edge.cap -= pushed
                    graph[edge.to][edge.rev].cap += pushed
                    return pushed
            ptr[v] += 1
        return 0
    
    max_flow = 0
    while True:
        if not bfs(S, T):
            break
        ptr[:] = [0] * total_nodes
        while True:
            pushed = dfs(S, T, INF)
            if pushed == 0:
                break
            max_flow += pushed
            if max_flow >= INF:
                break
        if max_flow >= INF:
            break
    
    print(-1 if max_flow >= INF else max_flow)

if __name__ == "__main__":
    main()
0