結果

問題 No.654 Air E869120
ユーザー lam6er
提出日時 2025-03-26 15:52:00
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 183 ms / 2,000 ms
コード長 5,079 bytes
コンパイル時間 297 ms
コンパイル使用メモリ 82,360 KB
実行使用メモリ 80,104 KB
最終ジャッジ日時 2025-03-26 15:52:53
合計ジャッジ時間 5,054 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 5
other AC * 35
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

import sys
import bisect
from collections import defaultdict, deque
class Edge:
    def __init__(self, to, rev, capacity):
        self.to = to
        self.rev = rev
        self.capacity = capacity
class MaxFlow:
    def __init__(self, n):
        self.size = n
        self.graph = [[] for _ in range(n)]
    
    def add_edge(self, fr, to, capacity):
        forward = Edge(to, len(self.graph[to]), capacity)
        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
def main():
    import sys
    input = sys.stdin.read().split()
    idx = 0
    N = int(input[idx]); idx +=1
    M = int(input[idx]); idx +=1
    d = int(input[idx]); idx +=1
    
    flights = []
    city_times = defaultdict(list)
    city_times[1].append(0)  # Initial time for city 1
    
    for _ in range(M):
        u = int(input[idx]); idx +=1
        v = int(input[idx]); idx +=1
        p = int(input[idx]); idx +=1
        q = int(input[idx]); idx +=1
        w = int(input[idx]); idx +=1
        flights.append( (u, v, p, q, w) )
        city_times[v].append(q)
    
    # Sort and deduplicate
    for u in city_times:
        times = city_times[u]
        times.sort()
        # Dedup
        new_times = []
        prev = None
        for t in times:
            if t != prev:
                new_times.append(t)
                prev = t
        city_times[u] = new_times
    
    # Assign nodes
    nodes = dict()  # (u, t) -> node_id
    node_counter = 0
    for u in city_times:
        for t in city_times[u]:
            nodes[ (u, t) ] = node_counter
            node_counter +=1
    
    # Flight nodes
    flight_nodes_start = node_counter
    for i in range(M):
        nodes[ ('flight', i) ] = flight_nodes_start + i
    node_counter += M
    
    # Super sink
    sink = node_counter
    node_counter +=1
    
    # Create MaxFlow instance
    mf = MaxFlow(node_counter)
    
    INF = 10**18
    
    # Add edges for each flight
    for i in range(M):
        u, v, p, q, w = flights[i]
        flight_node = nodes[ ('flight', i) ]
        # Edge flight_node -> (v, q)
        dest_node = nodes.get( (v, q), -1 )
        if dest_node == -1:
            continue  # Should not happen
        mf.add_edge( flight_node, dest_node, w )
        
        # Step 2c: if u is 1, add edge from (1,0) to flight_node
        if u == 1:
            source_node = nodes.get( (1, 0), -1 )
            if source_node != -1:
                mf.add_edge( source_node, flight_node, INF )
        
        # Step 2d: find latest t <= p -d in u's times
        times = city_times.get(u, [])
        if not times:
            continue
        latest_arrival = p - d
        idx_t = bisect.bisect_right(times, latest_arrival) -1
        if idx_t >=0:
            t = times[idx_t]
            from_node = nodes[ (u, t) ]
            mf.add_edge( from_node, flight_node, INF )
    
    # Add waiting edges for each city
    for u in city_times:
        times = city_times[u]
        for i in range(len(times)-1):
            t_prev = times[i]
            t_next = times[i+1]
            prev_node = nodes[ (u, t_prev) ]
            next_node = nodes[ (u, t_next) ]
            mf.add_edge( prev_node, next_node, INF )
    
    # Add edges from all (N, t) to sink
    if N in city_times:
        for t in city_times[N]:
            node = nodes[ (N, t) ]
            mf.add_edge( node, sink, INF )
    
    # Source is (1, 0)
    if (1, 0) not in nodes:
        print(0)
        return
    source = nodes[ (1, 0) ]
    
    # Compute max flow
    result = mf.max_flow(source, sink)
    print(result)
if __name__ == "__main__":
    main()
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0