結果

問題 No.1900 Don't be Powers of 2
コンテスト
ユーザー lam6er
提出日時 2025-03-31 17:23:45
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 120 ms / 2,000 ms
コード長 3,227 bytes
コンパイル時間 469 ms
コンパイル使用メモリ 82,112 KB
実行使用メモリ 79,576 KB
最終ジャッジ日時 2025-03-31 17:24:11
合計ジャッジ時間 4,818 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 42
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
from collections import deque, defaultdict

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
        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
        return flow

def main():
    input = sys.stdin.read().split()
    n = int(input[0])
    A = list(map(int, input[1:n+1]))
    
    freq = defaultdict(int)
    for x in A:
        freq[x] += 1
    elements = list(freq.keys())
    
    U = []
    V = []
    for x in elements:
        cnt = bin(x).count('1')
        if cnt % 2 == 0:
            U.append(x)
        else:
            V.append(x)
    
    len_U = len(U)
    len_V = len(V)
    id_map = {}
    current_id = 1
    for x in U:
        id_map[x] = current_id
        current_id += 1
    for x in V:
        id_map[x] = current_id
        current_id += 1
    
    total_nodes = len_U + len_V + 2
    dinic = Dinic(total_nodes)
    source = 0
    sink = total_nodes - 1
    INF = 1 << 60
    
    total_sum = sum(freq[x] for x in elements)
    
    for x in U:
        dinic.add_edge(source, id_map[x], freq[x])
    for x in V:
        dinic.add_edge(id_map[x], sink, freq[x])
    
    set_elements = set(elements)
    for x in U:
        for t in range(30):
            mask = 1 << t
            y = x ^ mask
            if y in set_elements and y in V:
                dinic.add_edge(id_map[x], id_map[y], INF)
    
    max_flow_val = dinic.max_flow(source, sink)
    print(total_sum - max_flow_val)

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