結果

問題 No.2328 Build Walls
コンテスト
ユーザー gew1fw
提出日時 2025-06-12 20:49:32
言語 PyPy3
(7.3.15)
結果
TLE  
実行時間 -
コード長 3,870 bytes
コンパイル時間 219 ms
コンパイル使用メモリ 82,032 KB
実行使用メモリ 71,424 KB
最終ジャッジ日時 2025-06-12 20:51:22
合計ジャッジ時間 6,839 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge1
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 10 TLE * 1 -- * 23
権限があれば一括ダウンロードができます

ソースコード

diff #
raw source code 

import sys
from collections import deque

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

class Dinic:
    def __init__(self, n):
        self.size = n
        self.graph = [[] for _ in range(n)]
    
    def add_edge(self, fr, to, cap):
        forward = Edge(to, len(self.graph[to]), cap)
        backward = Edge(fr, len(self.graph[fr]), 0)
        self.graph[fr].append(forward)
        self.graph[to].append(backward)
    
    def bfs_level(self, s, t, level):
        q = deque()
        level[:] = [-1] * self.size
        level[s] = 0
        q.append(s)
        while q:
            v = q.popleft()
            for edge in self.graph[v]:
                if edge.capacity > 0 and level[edge.to] == -1:
                    level[edge.to] = level[v] + 1
                    q.append(edge.to)
                    if edge.to == t:
                        return
    
    def dfs_flow(self, v, t, upTo, iter_, level):
        if v == t:
            return upTo
        for i in range(iter_[v], len(self.graph[v])):
            edge = self.graph[v][i]
            if edge.capacity > 0 and level[v] < level[edge.to]:
                d = self.dfs_flow(edge.to, t, min(upTo, edge.capacity), iter_, level)
                if d > 0:
                    edge.capacity -= d
                    self.graph[edge.to][edge.rev].capacity += d
                    return d
            iter_[v] += 1
        return 0
    
    def max_flow(self, s, t):
        flow = 0
        level = [-1] * self.size
        while True:
            self.bfs_level(s, t, level)
            if level[t] == -1:
                return flow
            iter_ = [0] * self.size
            while True:
                f = self.dfs_flow(s, t, float('inf'), iter_, level)
                if f == 0:
                    break
                flow += f
            level = [-1] * self.size

def main():
    H, W = map(int, sys.stdin.readline().split())
    INF = 1 << 60
    A = [[] for _ in range(H+1)]  # 1-based indexing for rows
    
    for i in range(2, H):
        A[i] = list(map(int, sys.stdin.readline().split()))
    
    total_nodes = 2 + 2 * H * W  # source(0), sink(1), in nodes (2~), out nodes (2+H*W~)
    dinic = Dinic(total_nodes)
    source = 0
    sink = 1
    
    for i in range(1, H+1):
        for j in range(1, W+1):
            if i == 1 or i == H:
                cap = INF
            else:
                if 2 <= i <= H-1:
                    a = A[i][j-1] if (j-1 < len(A[i])) else -1
                    if a == -1:
                        cap = INF
                    else:
                        cap = a
                else:
                    cap = INF  # shouldn't happen
            in_node = 2 + (i-1)*W + (j-1)
            out_node = in_node + H * W
            dinic.add_edge(in_node, out_node, cap)
    
    directions = [ (-1,0), (1,0), (0,-1), (0,1) ]
    for i in range(1, H+1):
        for j in range(1, W+1):
            in_node = 2 + (i-1)*W + (j-1)
            out_node = in_node + H * W
            for di, dj in directions:
                ni = i + di
                nj = j + dj
                if 1 <= ni <= H and 1 <= nj <= W:
                    neighbor_in = 2 + (ni-1)*W + (nj-1)
                    dinic.add_edge(out_node, neighbor_in, INF)
    
    # Connect source to row 1 in nodes
    for j in range(1, W+1):
        i = 1
        in_node = 2 + (i-1)*W + (j-1)
        dinic.add_edge(source, in_node, INF)
    
    # Connect row H out nodes to sink
    for j in range(1, W+1):
        i = H
        out_node = 2 + (i-1)*W + (j-1) + H * W
        dinic.add_edge(out_node, sink, INF)
    
    max_flow_val = dinic.max_flow(source, sink)
    if max_flow_val >= INF:
        print(-1)
    else:
        print(max_flow_val)

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