input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# -*- coding:utf-8 -*-
import sys
def search(x, y):
x_length = len(x)
y_length = len(y)
memo = [[0] * (y_length + 1) for i in range(x_length + 1)]
for i, ch_x in enumerate(x, 1):
row = memo[i]
pre_row = memo[i-1]
for j, ch_y in enumerate(y, 1):
if ch_x == ch_y:
row[j] = pre_row[j-1] + 1
else:
row[j] = max(pre_row[j], row[j-1])
return memo[-1][-1]
if __name__ == "__main__":
n = int(input())
strs = [list(val) for val in sys.stdin.read().splitlines()]
result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
print(*result, sep="\n")
| # -*- coding:utf-8 -*-
import sys
def search(x, y):
x_length = len(x)
y_length = len(y)
memo = [[0] * (y_length + 1) for i in range(x_length + 1)]
for i, ch_x in enumerate(x, 1):
row = memo[i]
pre_row = memo[i-1]
for j, ch_y in enumerate(y, 1):
if ch_x == ch_y:
row[j] = pre_row[j-1] + 1
elif pre_row[j] < row[j-1]:
row[j] = row[j-1]
else:
row[j] = pre_row[j]
return memo[-1][-1]
if __name__ == "__main__":
n = int(input())
strs = [list(val) for val in sys.stdin.read().splitlines()]
result = [search(strs[i*2], strs[i*2+1]) for i in range(n)]
print(*result, sep="\n")
| p02235 |
# 参考URL https://note.nkmk.me/python-union-find/
class UnionFind():
# 各要素の親要素の番号を格納するリスト
# 要素が根（ルート）の場合は-(そのグループの要素数)を格納する
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 要素xが属するグループの根を返す
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# 要素xが属するグループと要素yが属するグループとを併合する
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# 要素x, yが同じグループに属するかどうかを返す
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
from sys import stdin
def input():
return stdin.readline().strip()
n, q = list(map(int, input().split()))
uf = UnionFind(n)
ans = []
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
uf.union(u, v)
else:
if uf.same(u, v):
ans.append(1)
else:
ans.append(0)
for i in ans:
print(i)
main() | # Reference: https://note.nkmk.me/python-union-find/
class UnionFind:
# 各要素の親要素の番号を格納するリスト
# 要素が根（ルート）の場合は-(そのグループの要素数)を格納する
def __init__(self, n):
self.n = n
self.parents = [-1] * n
# 要素xが属するグループの根を返す
def find(self, x):
history = []
while self.parents[x] >= 0:
history.append(x)
x = self.parents[x]
for node in history:
self.parents[node] = x
return x
# 要素xが属するグループと要素yが属するグループとを併合する
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
# 要素x, yが同じグループに属するかどうかを返す
def same(self, x, y):
return self.find(x) == self.find(y)
def main():
from sys import stdin
input = stdin.buffer.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
ans = []
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
uf.union(u, v)
else:
if uf.same(u, v):
ans.append(1)
else:
ans.append(0)
for i in ans:
print(i)
main() | p02558 |
class DisjointSetUnion():
def __init__(self, n):
self.n = n
self.par_size = [-1] * n
def merge(self, a, b):
assert 0 <= a < self.n
assert 0 <= b < self.n
x = self.leader(a)
y = self.leader(b)
if x == y: return x
if -self.par_size[x] < -self.par_size[y]: x, y = y, x
self.par_size[x] += self.par_size[y]
self.par_size[y] = x
return x
def same(self, a, b):
assert 0 <= a < self.n
assert 0 <= b < self.n
return self.leader(a) == self.leader(b)
def leader(self, a):
assert 0 <= a < self.n
x = a
while self.par_size[x] >= 0:
x = self.par_size[x]
while self.par_size[a] >= 0:
self.par_size[a] = x
a = self.par_size[a]
return x
def size(self, a):
assert 0 <= a < self.n
return -self.par_size[self.leader(a)]
def groups(self):
leader_buf = [0] * self.n
group_size = [0] * self.n
res = [[] for _ in range(self.n)]
for i in range(self.n):
leader_buf[i] = self.leader(i)
group_size[leader_buf[i]] += 1
for i in range(self.n):
res[leader_buf[i]].append(i)
res = [res[i] for i in range(self.n) if res[i]]
return res
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
dsu = DisjointSetUnion(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t:
res.append(str(int(dsu.same(u, v))))
else:
dsu.merge(u, v)
print(('\n'.join(res))) | class DisjointSetUnion():
def __init__(self, n):
self.n = n
self.par_size = [-1] * n
def merge(self, a, b):
#assert 0 <= a < self.n
#assert 0 <= b < self.n
x = self.leader(a)
y = self.leader(b)
if x == y: return x
if -self.par_size[x] < -self.par_size[y]: x, y = y, x
self.par_size[x] += self.par_size[y]
self.par_size[y] = x
return x
def same(self, a, b):
#assert 0 <= a < self.n
#assert 0 <= b < self.n
return self.leader(a) == self.leader(b)
def leader(self, a):
#assert 0 <= a < self.n
x = a
while self.par_size[x] >= 0:
x = self.par_size[x]
while self.par_size[a] >= 0:
self.par_size[a] = x
a = self.par_size[a]
return x
def size(self, a):
#assert 0 <= a < self.n
return -self.par_size[self.leader(a)]
def groups(self):
leader_buf = [0] * self.n
group_size = [0] * self.n
res = [[] for _ in range(self.n)]
for i in range(self.n):
leader_buf[i] = self.leader(i)
group_size[leader_buf[i]] += 1
for i in range(self.n):
res[leader_buf[i]].append(i)
res = [res[i] for i in range(self.n) if res[i]]
return res
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
dsu = DisjointSetUnion(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t:
res.append(str(int(dsu.same(u, v))))
else:
dsu.merge(u, v)
print(('\n'.join(res))) | p02558 |
from typing import Set
class UnionFind:
"""Union-Find: O(α(N))"""
__slots__ = ["_data_size", "_first_idx", "_parents"]
def __init__(self, data_size: int, is_zero_origin: bool = True) -> None:
self._data_size = data_size
self._first_idx = 0 if is_zero_origin else 1
self._parents = [-1] * (data_size + self._first_idx)
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x."""
if self._parents[x] < 0:
return x
self._parents[x] = self[self._parents[x]]
return self._parents[x]
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> Set[int]:
"""Return the set of groups (roots)."""
return {
self[x] for x in range(self._first_idx, self._data_size + self._first_idx)
}
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected or not."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y."""
x, y = self[x], self[y]
if x == y:
return
if self._parents[x] > self._parents[y]:
x, y = y, x
self._parents[x] += self._parents[y]
self._parents[y] = x
def unite_all(self, *vertices: int) -> None:
"""Unite the groups of all of the given vertices."""
x = vertices[0]
for y in vertices[1:]:
self.unite(x, y)
def get_size(self, x: int) -> int:
"""Return the size of the group vertex x belongs."""
return -self._parents[self[x]]
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
unionfind()
| class UnionFind:
"""Union-Find: O(α(N))"""
__slots__ = ["_data_size", "_first_idx", "_parents"]
def __init__(self, data_size: int, is_zero_origin: bool = True) -> None:
self._data_size = data_size
self._first_idx = 0 if is_zero_origin else 1
self._parents = [-1] * (data_size + self._first_idx)
def _find(self, x: int) -> int:
if self._parents[x] < 0:
return x
self._parents[x] = self._find(self._parents[x])
return self._parents[x]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected or not."""
return self._find(x) == self._find(y)
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y."""
x, y = self._find(x), self._find(y)
if x == y:
return
if self._parents[x] > self._parents[y]:
x, y = y, x
self._parents[x] += self._parents[y]
self._parents[y] = x
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
unionfind()
| p02558 |
class UnionFind:
"""Union-Find: O(α(N))"""
__slots__ = ["_data_size", "_first_idx", "_parents"]
def __init__(self, data_size: int, is_zero_origin: bool = True) -> None:
self._data_size = data_size
self._first_idx = 0 if is_zero_origin else 1
self._parents = [-1] * (data_size + self._first_idx)
def _find(self, x: int) -> int:
if self._parents[x] < 0:
return x
self._parents[x] = self._find(self._parents[x])
return self._parents[x]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected or not."""
return self._find(x) == self._find(y)
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y."""
x, y = self._find(x), self._find(y)
if x == y:
return
if self._parents[x] > self._parents[y]:
x, y = y, x
self._parents[x] += self._parents[y]
self._parents[y] = x
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
unionfind()
| class UnionFind:
__slots__ = ["N", "root", "rank"]
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
def __repr__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x, yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.root[y] < self.root[x]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return -self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
def main():
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.union(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| p02558 |
from typing import Set
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> Set[int]:
"""Return the set of groups (roots) in O(n)."""
return {i for i, r in enumerate(self._roots) if r < 0}
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
unionfind()
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, N):
self._data_size = N
self._roots = [-1] * N
def find(self, x):
while self._roots[x] >= 0:
x = self._roots[x]
return x
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self._roots[y] < self._roots[x]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def is_connected(self, x, y):
return self.find(x) == self.find(y)
def main():
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| p02558 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
unionfind()
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, N):
self._data_size = N
self._roots = [-1] * N
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def unite(self, x, y):
x = self[x]
y = self[y]
if x == y:
return
elif self._roots[y] < self._roots[x]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def is_connected(self, x, y):
return self[x] == self[y]
def main():
N, Q, *TUV = list(map(int, open(0).read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| p02558 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
unionfind()
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, N):
self._data_size = N
self._roots = [-1] * N
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def unite(self, x, y):
x = self[x]
y = self[y]
if x == y:
return
elif self._roots[y] < self._roots[x]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def is_connected(self, x, y):
return self[x] == self[y]
def main():
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| p02558 |
class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, N):
self._data_size = N
self._roots = [-1] * N
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def unite(self, x, y):
x = self[x]
y = self[y]
if x == y:
return
elif self._roots[y] < self._roots[x]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def is_connected(self, x, y):
return self[x] == self[y]
def main():
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, N):
self._data_size = N
self._roots = [-1] * N
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def unite(self, x, y):
x = self[x]
y = self[y]
if x == y:
return
elif self._roots[y] < self._roots[x]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def is_connected(self, x, y):
return self[x] == self[y]
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| p02558 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> List[int]:
"""Return the set of groups (roots) in O(n)."""
return [i for i, r in enumerate(self._roots) if r < 0]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group where vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
def arc032_b():
# https://atcoder.jp/contests/arc032/tasks/arc032_2
N, M, *AB = list(map(int, open(0).read().split()))
tree = UnionFind(N + 1)
for a, b in zip(*[iter(AB)] * 2):
tree.unite(a, b)
print((len(tree) - 2))
if __name__ == "__main__":
unionfind()
# arc032_b()
| from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> List[int]:
"""Return the set of groups (roots) in O(n)."""
return [i for i, r in enumerate(self._roots) if r < 0]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group where vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| p02558 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> List[int]:
"""Return the set of groups (roots) in O(n)."""
return [i for i, r in enumerate(self._roots) if r < 0]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group where vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| p02558 |
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| p02558 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> List[int]:
"""Return the set of groups (roots) in O(n)."""
return [i for i, r in enumerate(self._roots) if r < 0]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group where vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
def arc032_b():
# https://atcoder.jp/contests/arc032/tasks/arc032_2
N, M, *AB = list(map(int, open(0).read().split()))
tree = UnionFind(N + 1)
for a, b in zip(*[iter(AB)] * 2):
tree.unite(a, b)
print((len(tree) - 2))
if __name__ == "__main__":
unionfind()
# arc032_b()
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| p02558 |
class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
readline = sys.stdin.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def main():
import sys
readline = sys.stdin.readline
N, Q = list(map(int, readline().split()))
tree = UnionFind(N)
res = []
for _ in range(Q):
t, u, v = list(map(int, readline().split()))
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
main()
| p02558 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
li = []
while self.parents[x] >= 0:
li.append(x)
x = self.parents[x]
for y in li:
self.parents[y] = x
return x
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
uf = UnionFind(N)
for i in range(Q):
t,u,v = list(map(int,input().split()))
if t == 0:
uf.union(u,v)
else:
if uf.same(u,v):
print((1))
else:
print((0))
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
li = []
while self.parents[x] >= 0:
if self.parents[self.parents[x]] >= 0:
self.parents[x] = self.parents[self.parents[x]]
x = self.parents[x]
return x
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
uf = UnionFind(N)
for i in range(Q):
t,u,v = list(map(int,input().split()))
if t == 0:
uf.union(u,v)
else:
if uf.same(u,v):
print((1))
else:
print((0))
| p02558 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
while self.parents[x] >= 0:
if self.parents[self.parents[x]] >= 0:
self.parents[x] = self.parents[self.parents[x]]
x = self.parents[x]
return x
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
uf = UnionFind(N)
for i in range(Q):
t,u,v = list(map(int,input().split()))
if t == 0:
uf.union(u,v)
else:
if uf.same(u,v):
print((1))
else:
print((0))
| class UnionFind():
def __init__(self, N):
self.N = N
self.parents = [-1] * N
def find(self, x):
if self.parents[x] < 0:
return x
else:
st = []
while self.parents[x] >= 0:
st.append(x)
x = self.parents[x]
for y in st:
self.parents[y] = x
return x
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
import sys
input = lambda:sys.stdin.buffer.readline().rstrip()
N,Q = list(map(int,input().split()))
uf = UnionFind(N)
for i in range(Q):
t,u,v = list(map(int,input().split()))
if t:
print((int(uf.same(u,v))))
else:
uf.union(u,v) | p02558 |
def main():
class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def find(self, x):
"""頂点xの根を見つける"""
if self.root[x] < 0:
return x
else:
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
import sys
n, q = list(map(int, sys.stdin.buffer.readline().split()))
uf = UnionFind(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
main()
| def main():
class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def find(self, x):
"""頂点xの根を見つける"""
if self.root[x] < 0:
return x
else:
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
import sys
n, q = list(map(int, sys.stdin.buffer.readline().split()))
uf = UnionFind(n)
for _ in range(q):
t, u, v = list(map(int, sys.stdin.buffer.readline().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
main()
| p02558 |
def main():
class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
if self.root[x] < 0:
return x
else:
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
ans = [0, 1]
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((ans[uf.same(u, v)]))
else:
uf.union(u, v)
main()
| class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
if self.root[x] < 0:
return x
else:
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
| p02558 |
import sys
input = sys.stdin.readline
def solve():
N, q = list(map(int, input().split()))
root = [-1] * N
rank = [0] * N
def find(x: int) -> int:
if root[x] < 0:
return x
else:
while root[x] >= 0:
x = root[x]
return x
def union(x: int, y: int):
x = find(x)
y = find(y)
if x == y:
return
elif rank[x] > rank[y]:
root[x] += root[y]
root[y] = x
else:
root[y] += root[x]
root[x] = y
if rank[x] == rank[y]:
rank[y] += 1
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(find(u) == find(v))))
else:
union(u, v)
solve()
| import sys
input = sys.stdin.readline
def solve():
N, q = list(map(int, input().split()))
root = [-1] * N
def find(x: int) -> int:
if root[x] < 0:
return x
else:
while root[x] >= 0:
x = root[x]
return x
def union(x: int, y: int):
x = find(x)
y = find(y)
if x == y:
return
if root[x] > root[y]:
x, y = y, x
root[x] += root[y]
root[y] = x
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(find(u) == find(v))))
else:
union(u, v)
solve()
| p02558 |
from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
result = self.leader(self.parent_or_size[a])
self.parent_or_size[a] = result
return result
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.merge(u, v)
| from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.merge(u, v)
| p02558 |
from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
result = self.leader(self.parent_or_size[a])
self.parent_or_size[a] = result
return result
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
uf = DSU(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.merge(u, v)
| from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
uf = DSU(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.merge(u, v)
| p02558 |
from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
uf = DSU(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.merge(u, v)
| class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
| p02558 |
class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
if self.root[x] < 0:
return x
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
| class UnionFind:
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
if self.root[x] < 0:
return x
else:
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
| p02558 |
class UnionFind:
__slots__ = ["N", "root", "rank"]
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
print((int(uf.same(u, v))))
else:
uf.union(u, v)
| class UnionFind:
__slots__ = ["N", "root", "rank"]
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.union(u, v)
print(("\n".join(map(str, res))))
| p02558 |
class UnionFind:
__slots__ = ["N", "root", "rank"]
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
self.rank = [0] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x,yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
uf = UnionFind(n)
res = []
for i in range(q):
t, u, v = map(int, input().split())
if t:
res.append(int(uf.same(u, v)))
else:
uf.union(u, v)
print(*res,sep="\n")
| class UnionFind:
__slots__ = ["N", "root", "rank"]
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
rank:ランク
"""
self.N = N
self.root = [-1] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
while self.root[x] >= 0:
x = self.root[x]
return x
def union(self, x, y):
"""x, yが属する木をunion"""
# 根を比較する
# すでに同じ木に属していた場合は何もしない.
# 違う木に属していた場合はrankを見てくっつける方を決める.
# rankが同じ時はrankを1増やす
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.root[y] < self.root[x]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.union(u, v)
print(("\n".join(map(str, res))))
| p02558 |
import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
update_list = []
while self.parent_or_size[a] >= 0:
update_list.append(a)
a = self.parent_or_size[a]
for i in update_list:
self.parent_or_size[i] = a
return a
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
r = a
while self.parent_or_size[r] >= 0:
r = self.parent_or_size[r]
while self.parent_or_size[a] >= 0:
self.parent_or_size[a], a = r, self.parent_or_size[a]
return r
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| p02558 |
import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
r = a
while self.parent_or_size[r] >= 0:
r = self.parent_or_size[r]
while self.parent_or_size[a] >= 0:
self.parent_or_size[a], a = r, self.parent_or_size[a]
return r
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list([r for r in result if r])
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = DSU(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.merge(u, v)
print(("\n".join(map(str, res))))
| class UnionFind:
__slots__ = ["N", "root"]
def __init__(self, N):
"""
N:要素数
root:各要素の親要素の番号を格納するリスト.
ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
"""
self.N = N
self.root = [-1] * N
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def find(self, x):
"""頂点xの根を見つける"""
r = x
while self.root[r] >= 0:
r = self.root[r]
while self.root[x] >= 0:
self.root[x], x = r, self.root[x]
return r
def union(self, x, y):
"""x, yが属する木をunion"""
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.root[y] < self.root[x]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def same(self, x, y):
"""xとyが同じグループに属するかどうか"""
return self.find(x) == self.find(y)
def count(self, x):
"""頂点xが属する木のサイズを返す"""
return - self.root[self.find(x)]
def members(self, x):
"""xが属する木の要素を列挙"""
_root = self.find(x)
return [i for i in range(self.N) if self.find(i) == _root]
def roots(self):
"""森の根を列挙"""
return [i for i, x in enumerate(self.root) if x < 0]
def group_count(self):
"""連結成分の数"""
return len(self.roots())
def all_group_members(self):
"""{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
return {r: self.members(r) for r in self.roots()}
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
uf = UnionFind(n)
res = []
for i in range(q):
t, u, v = list(map(int, input().split()))
if t:
res.append(int(uf.same(u, v)))
else:
uf.union(u, v)
print(("\n".join(map(str, res))))
| p02558 |
# UnionFind
import sys
def input(): return sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
from dataclasses import *
@dataclass
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,q=list(map(int,input().split()))
uf=UnionFind(n)
for _ in range(q):
t,u,v=list(map(int,input().split()))
if t==0:
uf.unite(u,v)
else:
print((uf.root_same(u,v)+0)) | # UnionFind
import sys
def input(): return sys.stdin.readline().rstrip()
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,q=list(map(int,input().split()))
uf=UnionFind(n)
for _ in range(q):
t,u,v=list(map(int,input().split()))
if t==0:
uf.unite(u,v)
else:
print((uf.root_same(u,v)+0)) | p02558 |
# UnionFind
import sys
def input(): return sys.stdin.readline().rstrip()
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,q=list(map(int,input().split()))
uf=UnionFind(n)
for _ in range(q):
t,u,v=list(map(int,input().split()))
if t==0:
uf.unite(u,v)
else:
print((uf.root_same(u,v)+0)) | # UnionFind
import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,q=list(map(int,input().split()))
uf=UnionFind(n)
for _ in range(q):
t,u,v=list(map(int,input().split()))
if t==0:
uf.unite(u,v)
else:
print((uf.root_same(u,v)+0)) | p02558 |
# UnionFind
import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,q=list(map(int,input().split()))
uf=UnionFind(n)
for _ in range(q):
t,u,v=list(map(int,input().split()))
if t==0:
uf.unite(u,v)
else:
print((uf.root_same(u,v)+0)) | import sys
input = lambda: sys.stdin.readline().rstrip()
# UnionFind
class UnionFind:
def __init__(self,n):
self.n=n
self.a=[-1]*n
self.siz=n
def root_find(self,x):
if self.a[x]<0:
return x
else:
self.a[x]=self.root_find(self.a[x])
return self.a[x]
def unite(self,x,y):
x=self.root_find(x)
y=self.root_find(y)
if x==y:
return
elif self.a[x]<self.a[y]:
self.a[x]+=self.a[y]
self.a[y]=x
else:
self.a[y]+=self.a[x]
self.a[x]=y
self.siz-=1
def root_same(self,x,y):
return self.root_find(x)==self.root_find(y)
n,q=list(map(int,input().split()))
u=UnionFind(n)
for _ in range(q):
t,a,b=list(map(int,input().split()))
if t==0:
u.unite(a,b)
else:
print((u.root_same(a,b)+0)) | p02558 |
# verify-helper: PROBLEM https://judge.yosupo.jp/problem/unionfind
import sys
input = sys.stdin.buffer.readline
class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
complexity:
- init: O(n)
- find, unite, same: O(alpha(n))
"""
def __init__(self, n: int) -> None:
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x: int) -> int:
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x: int, y: int) -> None:
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main() -> None:
N, Q = list(map(int, input().split()))
uft = UnionFindTree(N)
for _ in range(Q):
t, u, v = list(map(int, input().split()))
if t == 0:
uft.unite(u, v)
else:
print((int(uft.is_same(u, v))))
if __name__ == "__main__":
main()
| # verify-helper: PROBLEM https://judge.yosupo.jp/problem/unionfind
import sys
input = sys.stdin.buffer.readline
class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
complexity:
- init: O(n)
- find, unite, same: O(alpha(n))
"""
def __init__(self, n: int) -> None:
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x: int) -> int:
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x: int, y: int) -> None:
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main() -> None:
N, Q = map(int, input().split())
uft = UnionFindTree(N)
ans = []
for _ in range(Q):
t, u, v = map(int, input().split())
if t == 0:
uft.unite(u, v)
else:
ans.append(int(uft.is_same(u, v)))
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| p02558 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class UnionFind():
def __init__(self):
self.__table = {}
self.__size = defaultdict(lambda: 1)
self.__rank = defaultdict(lambda: 1)
def __root(self, x):
if x not in self.__table:
self.__table[x] = x
elif x != self.__table[x]:
self.__table[x] = self.__root(self.__table[x])
return self.__table[x]
def same(self, x, y):
return self.__root(x) == self.__root(y)
def union(self, x, y):
x = self.__root(x)
y = self.__root(y)
if x == y:
return False
if self.__rank[x] < self.__rank[y]:
self.__table[x] = y
self.__size[y] += self.__size[x]
else:
self.__table[y] = x
self.__size[x] += self.__size[y]
if self.__rank[x] == self.__rank[y]:
self.__rank[x] += 1
return True
def size(self, x):
return self.__size[self.__root(x)]
def num_of_group(self):
g = 0
for k, v in self.__table.items():
if k == v:
g += 1
return g
@mt
def slv(N, Q, TUV):
uf = UnionFind()
ans = []
for t, u, v in TUV:
if t == 1:
ans.append(1 if uf.same(u, v) else 0)
else:
uf.union(u, v)
return ans
def main():
N, Q = read_int_n()
TUV = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, TUV), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class UnionFind():
def __init__(self):
self.__table = {}
self.__size = defaultdict(lambda: 1)
self.__rank = defaultdict(lambda: 1)
def __root(self, x):
if x not in self.__table:
self.__table[x] = x
return x
else:
a = x
ul = []
while a != self.__table[a]:
ul.append(a)
a = self.__table[a]
for u in ul:
self.__table[u] = a
return self.__table[x]
def same(self, x, y):
return self.__root(x) == self.__root(y)
def union(self, x, y):
x = self.__root(x)
y = self.__root(y)
if x == y:
return False
if self.__rank[x] < self.__rank[y]:
self.__table[x] = y
self.__size[y] += self.__size[x]
else:
self.__table[y] = x
self.__size[x] += self.__size[y]
if self.__rank[x] == self.__rank[y]:
self.__rank[x] += 1
return True
def size(self, x):
return self.__size[self.__root(x)]
def num_of_group(self):
g = 0
for k, v in self.__table.items():
if k == v:
g += 1
return g
@mt
def slv(N, Q, TUV):
uf = UnionFind()
ans = []
for t, u, v in TUV:
if t == 1:
ans.append(1 if uf.same(u, v) else 0)
else:
uf.union(u, v)
return ans
def main():
N, Q = read_int_n()
TUV = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, TUV), sep='\n')
if __name__ == '__main__':
main()
| p02558 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self._parent = [i for i in range(n)]
self._rank = [0 for _ in range(n)]
self._group_size = [1 for _ in range(n)]
self.num_of_groups = n
def find(self, x):
# vs = []
while self._parent[x] != x:
# vs.append(x)
x = self._parent[x]
# for v in vs: self._parent[v] = x
return x
def union(self, x, y):
px, py = self.find(x), self.find(y)
if px == py: return
if self._rank[px] < self._rank[py]:
self._parent[px] = py
self._group_size[py] += self._group_size[px]
else:
self._parent[py] = px
self._group_size[px] += self._group_size[py]
if self._rank[px] == self._rank[py]:
self._rank[py] += 1
self.num_of_groups -= 1
def is_same(self, x, y): return self.find(x) == self.find(y)
def group_size(self, x): return self._group_size[self.find(x)]
def main():
N, Q = LI()
TUV = LIR(Q)
uf = UnionFind(N+1)
for t, u, v in TUV:
if t == 0:
uf.union(u, v)
else:
print((int(uf.is_same(u, v))))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self._parent, self._rank, self._group_size = [i for i in range(n)], [0 for _ in range(n)], [1 for _ in range(n)]
self.num_of_groups = n
def find(self, x):
vs = []
while self._parent[x] != x:
vs.append(x)
x = self._parent[x]
for v in vs: self._parent[v] = x
return x
def union(self, x, y):
px, py = self.find(x), self.find(y)
if px == py: return
if self._rank[px] < self._rank[py]:
self._parent[px] = py
self._group_size[py] += self._group_size[px]
else:
self._parent[py] = px
self._group_size[px] += self._group_size[py]
if self._rank[px] == self._rank[py]: self._rank[py] += 1
self.num_of_groups -= 1
def is_same(self, x, y): return self.find(x) == self.find(y)
def group_size(self, x): return self._group_size[self.find(x)]
def main():
N, Q = LI()
TUV = LIR(Q)
uf = UnionFind(N+1)
for t, u, v in TUV:
if t == 0:
uf.union(u, v)
else:
print((int(uf.is_same(u, v))))
if __name__ == '__main__':
main() | p02558 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self._parent, self._rank, self._group_size = [i for i in range(n)], [0 for _ in range(n)], [1 for _ in range(n)]
self.num_of_groups = n
def find(self, x):
vs = []
while self._parent[x] != x:
vs.append(x)
x = self._parent[x]
for v in vs: self._parent[v] = x
return x
def union(self, x, y):
px, py = self.find(x), self.find(y)
if px == py: return
if self._rank[px] < self._rank[py]:
self._parent[px] = py
self._group_size[py] += self._group_size[px]
else:
self._parent[py] = px
self._group_size[px] += self._group_size[py]
if self._rank[px] == self._rank[py]: self._rank[py] += 1
self.num_of_groups -= 1
def is_same(self, x, y): return self.find(x) == self.find(y)
def group_size(self, x): return self._group_size[self.find(x)]
def main():
N, Q = LI()
TUV = LIR(Q)
uf = UnionFind(N+1)
for t, u, v in TUV:
if t == 0:
uf.union(u, v)
else:
print((int(uf.is_same(u, v))))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, N): self.N, self.root, self.rank = N, [-1] * N, [0] * N
def __repr__(self): return '\n'.join(f"{r}: {self.members(r)}" for r in self.roots())
def find(self, x):
while self.root[x] >= 0: x = self.root[x]
return x
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x == y: return
if self.rank[x] > self.rank[y]: x, y = y, x
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]: self.rank[y] += 1
def same(self, x, y): return self.find(x) == self.find(y)
def count(self, x): return -self.root[self.find(x)]
def members(self, x): return [i for i in range(self.N) if self.same(x, i)]
def roots(self): return [i for i, x in enumerate(self.root) if x < 0]
def all_groups(self): return {r: self.members(r) for r in self.roots()}
def main():
N, Q = LI()
TUV = LIR(Q)
uf = UnionFind(N+1)
for t, u, v in TUV:
if t == 0:
uf.union(u, v)
else:
print((int(uf.same(u, v))))
if __name__ == '__main__':
main() | p02558 |
class dsu:
def __init__(self, n=0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if self.parent_or_size[x] > self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
x = a
while self.parent_or_size[x] >= 0:
x = self.parent_or_size[x]
while a != x:
self.parent_or_size[a], a = x, self.parent_or_size[a]
return x
def size(self, a: int) -> int:
return -self.parent_or_size[self.leader(a)]
def groups(self):
g = [[] for _ in range(self._n)]
for i in range(self._n):
g[self.leader(i)].append(i)
return list(c for c in g if c)
n, q = list(map(int, input().split()))
d = dsu(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
d.merge(u, v)
else:
print((int(d.same(u, v)))) | class dsu:
def __init__(self, n=0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if self.parent_or_size[x] > self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
x = a
while self.parent_or_size[x] >= 0:
x = self.parent_or_size[x]
while a != x:
self.parent_or_size[a], a = x, self.parent_or_size[a]
return x
def size(self, a: int) -> int:
return -self.parent_or_size[self.leader(a)]
def groups(self):
g = [[] for _ in range(self._n)]
for i in range(self._n):
g[self.leader(i)].append(i)
return list(c for c in g if c)
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
d = dsu(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
d.merge(u, v)
else:
print((int(d.same(u, v))))
| p02558 |
from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
stack = []
while self.parent_or_size[a] >= 0:
stack.append(a)
a = self.parent_or_size[a]
for i in stack:
self.parent_or_size[i] = a
return a
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| p02558 |
from typing import List
class DSU:
def __init__(self, n: int) -> None:
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a <= self._n
assert 0 <= b <= self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a: int) -> int:
assert 0 <= a <= self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> List[List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| class DSU:
def __init__(self, n):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a, b):
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a, b):
return self.leader(a) == self.leader(b)
def leader(self, a):
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a):
return -self.parent_or_size[self.leader(a)]
def groups(self):
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| p02558 |
class DSU:
def __init__(self, n):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a, b):
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a, b):
return self.leader(a) == self.leader(b)
def leader(self, a):
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a):
return -self.parent_or_size[self.leader(a)]
def groups(self):
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| import sys
input = sys.stdin.readline
class DSU:
def __init__(self, n):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a, b):
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a, b):
return self.leader(a) == self.leader(b)
def leader(self, a):
while self.parent_or_size[a] >= 0:
a = self.parent_or_size[a]
return a
def size(self, a):
return -self.parent_or_size[self.leader(a)]
def groups(self):
leader_buf = [self.leader(i) for i in range(self._n)]
group_size = [0] * self._n
for i in leader_buf:
group_size[i] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [i for i in result if i]
return result
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| p02558 |
import sys
input = sys.stdin.readline
class DSU:
__slots__ = ["_n", "parent_or_size"]
def __init__(self, n):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a, b):
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a, b):
return self.leader(a) == self.leader(b)
def leader(self, a):
stack = []
while self.parent_or_size[a] >= 0:
stack.append(a)
a = self.parent_or_size[a]
for i in stack:
self.parent_or_size[i] = a
return a
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
| import sys
input = sys.stdin.readline
class DSU:
__slots__ = ["_n", "parent_or_size"]
def __init__(self, n):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a, b):
x, y = self.leader(a), self.leader(b)
if x == y:
return x
if self.parent_or_size[x] > self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a, b):
return self.leader(a) == self.leader(b)
def leader(self, a):
stack = []
while self.parent_or_size[a] >= 0:
stack.append(a)
a = self.parent_or_size[a]
for i in stack:
self.parent_or_size[i] = a
return a
def main():
n, q = list(map(int, input().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:
dsu.merge(u, v)
else:
print((1 if dsu.same(u, v) else 0))
main() | p02558 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.size = [1] * (n + 1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
x = self.find(x); y = self.find(y)
if self.rank[x] < self.rank[y]:
if self.same_check(x, y) != True:
self.size[y] += self.size[x]
self.size[x] = 0
self.par[x] = y
else:
if self.same_check(x, y) != True:
self.size[x] += self.size[y]
self.size[y] = 0
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getsize(self, x):
x = self.find(x)
return self.size[x]
def main():
N, Q = getlist()
UF = UnionFind(N)
for i in range(Q):
q, u, v = getlist()
if q == 0:
UF.union(u, v)
else:
if UF.same_check(u, v):
print((1))
else:
print((0))
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.size = [1] * (n + 1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x); y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.size[y] += self.size[x]
self.size[x] = 0
self.par[x] = y
else:
self.size[x] += self.size[y]
self.size[y] = 0
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
def getsize(self, x):
x = self.find(x)
return self.size[x]
def main():
N, Q = getlist()
UF = UnionFind(N)
for i in range(Q):
q, u, v = getlist()
if q == 0:
UF.union(u, v)
else:
if UF.same_check(u, v):
print((1))
else:
print((0))
if __name__ == '__main__':
main() | p02558 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def num_roots(self):
return len([i for i, x in enumerate(self.parents) if x < 0])
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def num_members(self,x):
return abs(self.parents[self.find(x)])
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.readline
N, Q = map(int, input().split())
uf = UnionFind(N)
ans = []
for i in range(Q):
t,u,v = map(int, input().split())
if t==0:
uf.union(u,v)
else:
if uf.same(u,v):
ans.append(1)
else:
ans.append(0)
print(*ans, sep='\n')
| class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def num_roots(self):
return len([i for i, x in enumerate(self.parents) if x < 0])
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def num_members(self,x):
return abs(self.parents[self.find(x)])
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
import sys
input = sys.stdin.readline
N, Q = map(int, input().split())
uf = UnionFind(N)
ans = []
for i in range(Q):
t,u,v = map(int, input().split())
if t:
ans.append(int(uf.same(u,v)))
else:
uf.union(u,v)
print(*ans, sep='\n')
| p02558 |
import types
# from atcoder.dsu import DSU
_atcoder_code = """
# Python port of AtCoder Library.
"""
atcoder = types.ModuleType('atcoder')
exec(_atcoder_code, atcoder.__dict__)
_atcoder_dsu_code = """
import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
self.parent_or_size[a] = self.leader(self.parent_or_size[a])
return self.parent_or_size[a]
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list(filter(lambda r: r, result))
"""
atcoder.dsu = types.ModuleType('atcoder.dsu')
exec(_atcoder_dsu_code, atcoder.dsu.__dict__)
DSU = atcoder.dsu.DSU
def main() -> None:
import sys
n, q = list(map(int, sys.stdin.readline().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, sys.stdin.readline().split()))
if t == 0:
dsu.merge(u, v)
if t == 1:
if dsu.same(u, v):
print((1))
else:
print((0))
if __name__ == '__main__':
main()
| import types
_atcoder_code = """
# Python port of AtCoder Library.
__version__ = '0.0.1'
"""
atcoder = types.ModuleType('atcoder')
exec(_atcoder_code, atcoder.__dict__)
_atcoder_dsu_code = """
import typing
class DSU:
'''
Implement (union by size) + (path compression)
Reference:
Zvi Galil and Giuseppe F. Italiano,
Data structures and algorithms for disjoint set union problems
'''
def __init__(self, n: int = 0):
self._n = n
self.parent_or_size = [-1] * n
def merge(self, a: int, b: int) -> int:
assert 0 <= a < self._n
assert 0 <= b < self._n
x = self.leader(a)
y = self.leader(b)
if x == y:
return x
if -self.parent_or_size[x] < -self.parent_or_size[y]:
x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a < self._n
assert 0 <= b < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a < self._n
if self.parent_or_size[a] < 0:
return a
self.parent_or_size[a] = self.leader(self.parent_or_size[a])
return self.parent_or_size[a]
def size(self, a: int) -> int:
assert 0 <= a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self) -> typing.List[typing.List[int]]:
leader_buf = [self.leader(i) for i in range(self._n)]
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
return list(filter(lambda r: r, result))
"""
atcoder.dsu = types.ModuleType('atcoder.dsu')
exec(_atcoder_dsu_code, atcoder.dsu.__dict__)
DSU = atcoder.dsu.DSU
# https://atcoder.jp/contests/practice2/tasks/practice2_a
# from atcoder.dsu import DSU
def main() -> None:
import sys
n, q = list(map(int, sys.stdin.readline().split()))
dsu = DSU(n)
for _ in range(q):
t, u, v = list(map(int, sys.stdin.readline().split()))
if t == 0:
dsu.merge(u, v)
if t == 1:
if dsu.same(u, v):
print((1))
else:
print((0))
if __name__ == '__main__':
main()
| p02558 |
class UnionFind:
def __init__(self, n: int) -> None:
self.forest = [-1] * n
def union(self, x: int, y: int) -> None:
x = self.findRoot(x)
y = self.findRoot(y)
if x == y:
return
if self.forest[x] > self.forest[y]:
x, y = y, x
self.forest[x] += self.forest[y]
self.forest[y] = x
return
def findRoot(self, x: int) -> int:
if self.forest[x] < 0:
return x
else:
self.forest[x] = self.findRoot(self.forest[x])
return self.forest[x]
def issame(self, x: int, y: int) -> bool:
return self.findRoot(x) == self.findRoot(y)
def size(self, x: int) -> int:
return -self.forest[self.findRoot(x)]
n,q = list(map(int,input().split()))
uf = UnionFind(n)
for i in range(q):
ti,ui,vi = list(map(int,input().split()))
if ti:
print((int(uf.issame(ui,vi))))
else:
uf.union(vi,ui)
| import sys
class UnionFind:
def __init__(self, n: int) -> None:
self.forest = [-1] * n
def union(self, x: int, y: int) -> None:
x = self.findRoot(x)
y = self.findRoot(y)
if x == y:
return
if self.forest[x] > self.forest[y]:
x, y = y, x
self.forest[x] += self.forest[y]
self.forest[y] = x
return
def findRoot(self, x: int) -> int:
if self.forest[x] < 0:
return x
else:
self.forest[x] = self.findRoot(self.forest[x])
return self.forest[x]
def issame(self, x: int, y: int) -> bool:
return self.findRoot(x) == self.findRoot(y)
def size(self, x: int) -> int:
return -self.forest[self.findRoot(x)]
def main():
input = sys.stdin.readline
n,q = list(map(int,input().split()))
uf = UnionFind(n)
for i in range(q):
ti,ui,vi = list(map(int,input().split()))
if ti:
print((int(uf.issame(ui,vi))))
else:
uf.union(vi,ui)
if __name__ == "__main__":
main()
| p02558 |
#!/usr/bin/env python
n, q = list(map(int ,input().split()))
par = [-1 for _ in range(n)]
rank = [-1 for _ in range(n)]
def init(n):
for i in range(n):
par[i] = i
rank[i] = 0
def root(x):
if par[x] == x:
return x
# ここをしっかり理解する
else:
par[x] = root(par[x])
return par[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
x = root(x)
y = root(y)
if x == y:
return
par[x] = y
# main
t = [0 for _ in range(q)]
u = [0 for _ in range(q)]
v = [0 for _ in range(q)]
init(n)
for i in range(q):
t[i], u[i], v[i] = list(map(int, input().split()))
if t[i] == 0:unite(u[i], v[i])
else:print((int(same(u[i], v[i]))))
| #!/usr/bin/env python
class UnionFind():
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.sizes = [1 for _ in range(n)]
def root(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.root(self.par[x]) # 圧縮経路
return self.par[x]
# return root(par[x]) # 圧縮しない場合
def same(self, x, y):
return self.root(x) == self.root(y)
def unite(self, x, y):
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
# par[rx] = ry # naiveな連結
# 低い木を高い方にくっつける。
if self.rank[rx] < self.rank[ry]:
self.par[rx] = ry
self.sizes[ry] += self.sizes[rx]
else:
self.par[ry] = rx
self.sizes[rx] += self.sizes[ry]
# rx木とry木の高さが同じならば、rx木を深くする。
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def size(self, x):
'''
xが属するグループのサイズを返す
(連結成分の大きさ)
'''
return self.sizes[self.root(x)]
# main
n, q = list(map(int ,input().split()))
uf = UnionFind(n)
for i in range(q):
t, u, v = list(map(int, input().split()))
if t == 0:uf.unite(u, v)
else:print((int(uf.same(u, v))))
| p02558 |
s,k = input().split()
mod = 998244353
k = int(k)
k = min(200,k)
raw = [0]
l = len(s)
for i in range(l):
if s[i] == '0':
raw.append(0)
else:
raw[-1] += 1
#print(raw)
now = [[0 for _ in range(k+1)] for _ in range(k+1)]
l = len(raw)
raw.reverse()
#print(raw)
now[0][0] = 1
for x in raw:
last = now[:]
now = [[0 for _ in range(k+1)] for _ in range(k+1)]
for i in range(k+1):
for j in range(k+1):
for mag in range(x+1):
if mag + i > k or mag + j > k:
continue
now[i+mag][j+mag] += last[i][j]
now[i+mag][j+mag] %= mod
for dim in range(j):
now[i][dim] += last[i][j]
now[i][dim] %= mod
#print(now)
#print(now)
ans = 0
for i in range(k+1):
ans += now[i][0]
print((ans%mod)) | s,k = input().split()
mod = 998244353
k = int(k)
k = min(300,k)
raw = [0]
l = len(s)
for i in range(l):
if s[i] == '0':
raw.append(0)
else:
raw[-1] += 1
#print(raw)
now = [[0 for _ in range(k+1)] for _ in range(k+1)]
l = len(raw)
raw.reverse()
#print(raw)
now[0][0] = 1
for x in raw:
last = now[:]
now = []
for i in range(k+1):
use = last[i][:]
use.reverse()
cum = []
for j in range(k+1):
if cum:
cum.append(cum[-1]+use[j])
cum[-1] %= mod
else:
cum = [use[0]]
cum.reverse()
now.append(cum)
#print(cum)
#print('#')
cum2 = []
for i in range(k+1):
cum = [0 for _ in range(i)]
cum.append(last[i][0])
#print('%',cum)
for l in range(i+1,k+1):
cum.append(cum[-1]+last[l][l-i])
#print(cum)
cum2.append(cum)
for i in range(k+1):
for j in range(k+1):
if j > i:
pass
now[i][j] += cum2[i-j][i]
if i - x - 1 >= 0:
now[i][j] -= cum2[i-j][i-x-1]
now[i][j] %= mod
for i in range(k+1):
for j in range(k+1):
now[i][j] -= last[i][j]
now[i][j] %= mod
#print(now)
#print('##')
#print(now)
#print(now)
ans = 0
for i in range(k+1):
ans += now[i][0]
print((ans%mod)) | p02635 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 5)
MOD = 998244353
# TLE
def solve(S, K):
numZeroes = S.count("0")
# Count number of ones before each zero. This is a unique representation of the string
ones = [0 for i in range(numZeroes + 1)]
j = 0
for x in S:
if x == "0":
j += 1
else:
assert x == "1"
ones[j] += 1
# The ones can move to behind an earlier zero. At most K of them can move.
# Always best to move directly to desired location
@lru_cache(maxsize=None)
def numWays(i, usedK, extraOnes):
if usedK == K and extraOnes == 0:
return 1
if i == 0:
# If first zero, have to use up all the extra ones
return 1
# Keep current value
ways = numWays(i - 1, usedK, extraOnes)
# Use up some extra ones to increment curr
for j in range(1, extraOnes + 1):
ways += numWays(i - 1, usedK, extraOnes - j)
ways %= MOD
# Steal some ones to decrement curr
for j in range(1, ones[i] + 1):
if usedK + j > K:
break
ways += numWays(i - 1, usedK + j, extraOnes + j)
ways %= MOD
return ways % MOD
return numWays(len(ones) - 1, 0, 0) % MOD
def solve(S, K):
numZeroes = S.count("0")
numOnes = len(S) - numZeroes
# Count number of ones before each zero. This is a unique representation of the string
ones = [0 for i in range(numZeroes + 1)]
j = 0
for x in S:
if x == "0":
j += 1
else:
assert x == "1"
ones[j] += 1
numWays = [
[[None for extraOnes in range(numOnes + 1)] for usedK in range(K + 1)]
for i in range(len(ones))
]
for i in range(len(ones)):
numWays[i][K][0] = 1
for usedK in range(K + 1):
for extraOnes in range(numOnes + 1):
numWays[0][usedK][extraOnes] = 1
for i in range(len(ones)):
for usedK in range(K, -1, -1):
for extraOnes in range(numOnes, -1, -1):
if usedK == K and extraOnes == 0:
continue
if i == 0:
continue
# Keep current value
ways = numWays[i - 1][usedK][extraOnes]
# Use up some extra ones to increment curr
for j in range(1, extraOnes + 1):
ways += numWays[i - 1][usedK][extraOnes - j]
ways %= MOD
# Steal some ones to decrement curr
for j in range(1, ones[i] + 1):
if usedK + j > K or extraOnes + j > numOnes:
break
ways += numWays[i - 1][usedK + j][extraOnes + j]
ways %= MOD
numWays[i][usedK][extraOnes] = ways % MOD
return numWays[len(ones) - 1][0][0] % MOD
S, K = input().split()
S = list(S)
K = int(K)
print((solve(S, K)))
| from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 5)
MOD = 998244353
# TLE
def solve(S, K):
numZeroes = S.count("0")
# Count number of ones before each zero. This is a unique representation of the string
ones = [0 for i in range(numZeroes + 1)]
j = 0
for x in S:
if x == "0":
j += 1
else:
assert x == "1"
ones[j] += 1
# The ones can move to behind an earlier zero. At most K of them can move.
# Always best to move directly to desired location to use fewer moves
@lru_cache(maxsize=None)
def numWays(i, usedK, extraOnes):
if usedK == K and extraOnes == 0:
return 1
if i == 0:
# If first zero, have to use up all the extra ones
return 1
# Keep current value
ways = numWays(i - 1, usedK, extraOnes)
# Use up some extra ones to increment curr
for j in range(1, extraOnes + 1):
ways += numWays(i - 1, usedK, extraOnes - j)
ways %= MOD
# Steal some ones to decrement curr
for j in range(1, ones[i] + 1):
if usedK + j > K:
break
ways += numWays(i - 1, usedK + j, extraOnes + j)
ways %= MOD
return ways % MOD
return numWays(len(ones) - 1, 0, 0) % MOD
# TLE
def solve(S, K):
numZeroes = S.count("0")
numOnes = len(S) - numZeroes
# Count number of ones before each zero. This is a unique representation of the string
ones = [0 for i in range(numZeroes + 1)]
j = 0
for x in S:
if x == "0":
j += 1
else:
assert x == "1"
ones[j] += 1
# The ones can move to behind an earlier zero. At most K of them can move.
# Always best to move directly to desired location to use fewer moves
K = min(K, numOnes)
numWays = [
[[None for extraOnes in range(numOnes + 1)] for usedK in range(K + 1)]
for i in range(len(ones))
]
for i in range(len(ones)):
numWays[i][K][0] = 1
for usedK in range(K + 1):
for extraOnes in range(numOnes + 1):
numWays[0][usedK][extraOnes] = 1
for i in range(len(ones)):
for usedK in range(K, -1, -1):
for extraOnes in range(usedK, -1, -1):
if usedK == K and extraOnes == 0:
continue
if i == 0:
continue
# Keep current value
ways = numWays[i - 1][usedK][extraOnes]
# Use up some extra ones to increment curr
for j in range(1, extraOnes + 1):
ways += numWays[i - 1][usedK][extraOnes - j]
ways %= MOD
# Steal some ones to decrement curr
for j in range(1, ones[i] + 1):
if usedK + j > K or extraOnes + j > numOnes:
break
ways += numWays[i - 1][usedK + j][extraOnes + j]
ways %= MOD
numWays[i][usedK][extraOnes] = ways % MOD
return numWays[len(ones) - 1][0][0] % MOD
S, K = input().split()
S = list(S)
K = int(K)
print((solve(S, K)))
| p02635 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 998244353
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
s,K=input().split()
K=int(K)
l=len(s)
if K>l:
K=l
sep=[]
count=0
for i in range(l):
if s[i]=="1": count+=1
else:
sep.append(count)
count=0
sep.append(count)
dp=[[[0]*(K+1) for _ in range(l+1)] for _ in range(len(sep))]
#dp[i][j][k] 末尾からi番目の領域、j個の0をストック,k回の操作
dp[0][0][0]=1
for i in range(1,min(sep[-1]+1,K+1)):
dp[0][i][i]=1
for i in range(1,len(sep)):
ori=sep[-1-i]
for j in range(l+1):
dpi=dp[i][j]
dpp=dp[i-1]
for k in range(K+1):
for pj in range(max(0,j-ori),j):
pk=k-(j-pj)
if pk>=0:
dpi[k]+=dpp[pj][pk]
dpi[k]%=mod
for pj in range(j,l+1):
dpi[k]+=dpp[pj][k]
dpi[k]%=mod
ans=0
for k in dp[-1][0]:
ans+=k
ans%=mod
print(ans)
#print(dp)
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 998244353
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
s,K=input().split()
K=int(K)
l=len(s)
if K>l:
K=l
sep=[]
count=0
for i in range(l):
if s[i]=="1": count+=1
else:
sep.append(count)
count=0
sep.append(count)
dp=[[[0]*(l+1) for _ in range(K+1)] for _ in range(len(sep))]
#dp[i][j][k] 末尾からi番目の領域、j個の0をストック,k回の操作
dp[0][0][0]=1
for i in range(1,min(sep[-1]+1,K+1)):
dp[0][i][i]=1
dp20=[[0]*(l+1) for _ in range(K+1)]
for i in range(1,len(sep)):
ori=sep[-1-i]
dp2=deepcopy(dp20)
for k in range(K+1):
dp[i][k][-1]=dp[i-1][k][-1]
for j in range(1,l+1):
dp[i][k][-1-j]=(dp[i][k][-j]+dp[i-1][k][-1-j])%mod
if k==0 or j==0: continue
dp2[k][j]=(dp2[k-1][j-1]+dp[i-1][k-1][j-1])%mod
if j>ori and k>ori:
dp2[k][j]-=dp[i-1][k-ori-1][j-ori-1]
dp2[k][j]%=mod
for k in range(K+1):
for j in range(1,l+1):
dp[i][k][j]=(dp[i][k][j]+dp2[k][j])%mod
ans=0
for k in range(K+1):
ans+=dp[-1][k][0]
ans%=mod
print(ans)
#print(dp)
if __name__ == "__main__":
main()
| p02635 |
S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
dp=[[0 for i in range(K+1)] for j in range(K+1)]
for j in range(K+1):
dp[j][j]=1
for i in range(m-1,-1,-1):
ndp=[[0 for x in range(K+1)] for y in range(K+1)]
for j in range(K,-1,-1):
for k in range(K,-1,-1):
M=max(k-j,-a[i])
for l in range(max(0,M),K-j+1):
ndp[j][k]+=dp[j+l][k]
ndp[j][k]%=mod
for l in range(1,min(K-k,-M)+1):
ndp[j][k]+=dp[j][k+l]
ndp[j][k]%=mod
dp=ndp
print((dp[0][0]))
| S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
dp=[[[0 for i in range(K+1)] for j in range(K+1)] for k in range(m+1)]
for j in range(K+1):
dp[m][j][j]=1
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
for i in range(m-1,-1,-1):
for j in range(K+1):
for k in range(min(b[i],K)+1):
M=max(k-j,-a[i])
dp[i][j][k]=sum(dp[i+1][j+l][k] for l in range(max(0,M),K-j+1))+sum(dp[i+1][j][k+l] for l in range(1,min(K-k,-M)+1))
dp[i][j][k]%=mod
print((dp[0][0][0]))
| p02635 |
S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
dp=[[[0 for i in range(K+1)] for j in range(K+1)] for k in range(m+1)]
for j in range(K+1):
dp[m][j][j]=1
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
for i in range(m-1,-1,-1):
for j in range(K+1):
for k in range(min(b[i],K)+1):
M=max(k-j,-a[i])
dp[i][j][k]=sum(dp[i+1][j+l][k] for l in range(max(0,M),K-j+1))+sum(dp[i+1][j][k+l] for l in range(1,min(K-k,-M)+1))
dp[i][j][k]%=mod
print((dp[0][0][0]))
| S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
dp=[[[0 for i in range(K+1)] for j in range(K+1)] for k in range(m+1)]
for j in range(K+1):
dp[m][j][j]=1
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
for i in range(m-1,-1,-1):
for k in range(min(b[i],K)+1):
for j in range(min(K,k+c[i])+1):
M=max(k-j,-a[i])
dp[i][j][k]=sum(dp[i+1][j+l][k] for l in range(max(0,M),K-j+1))+sum(dp[i+1][j][k+l] for l in range(1,min(K-k,-M)+1))
dp[i][j][k]%=mod
print((dp[0][0][0])) | p02635 |
S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
dp=[[[0 for i in range(K+1)] for j in range(K+1)] for k in range(m+1)]
for j in range(K+1):
dp[m][j][j]=1
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
for i in range(m-1,-1,-1):
for k in range(min(b[i],K)+1):
for j in range(min(K,k+c[i])+1):
M=max(k-j,-a[i])
dp[i][j][k]=sum(dp[i+1][j+l][k] for l in range(max(0,M),K-j+1))+sum(dp[i+1][j][k+l] for l in range(1,min(K-k,-M)+1))
dp[i][j][k]%=mod
print((dp[0][0][0])) | S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
dp=[[0 for i in range(K+1)] for j in range(K+1)]
for j in range(K+1):
dp[j][j]=1
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
for i in range(m-1,-1,-1):
ndp=[[0 for j in range(K+1)] for k in range(K+1)]
for k in range(min(b[i],K)+1):
for j in range(min(K,k+c[i])+1):
M=max(k-j,-a[i])
ndp[j][k]=sum(dp[j+l][k] for l in range(max(0,M),K-j+1))+sum(dp[j][k+l] for l in range(1,min(K-k,-M)+1))
ndp[j][k]%=mod
dp=ndp
print((dp[0][0]))
| p02635 |
S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
dp=[[0 for i in range(K+1)] for j in range(K+1)]
for j in range(K+1):
dp[j][j]=1
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
for i in range(m-1,-1,-1):
ndp=[[0 for j in range(K+1)] for k in range(K+1)]
for k in range(min(b[i],K)+1):
for j in range(min(K,k+c[i])+1):
M=max(k-j,-a[i])
for l in range(max(0,M),K-j+1):
ndp[j][k]=(ndp[j][k]+dp[j+l][k])%mod
for l in range(1,min(K-k,-M)+1):
ndp[j][k]=(ndp[j][k]+dp[j][k+l])%mod
dp=ndp
print((dp[0][0])) | S,K=input().split()
K=int(K)
K=min(K,300)
mod=998244353
a=[]
val=0
for i in range(len(S)):
if S[i]=="0":
a.append(val)
val=0
else:
val+=1
if val!=0:
a.append(val)
m=len(a)
K=min(sum(a),K)
b=[a[i] for i in range(m)]
c=[a[i] for i in range(m)]
for i in range(1,m):
b[i]+=b[i-1]
b=[0]+b
for i in range(m-2,-1,-1):
c[i]+=c[i+1]
dp=[[0 for i in range(K+1)] for j in range(K+1)]
plus=[[0 for j in range(K+1)] for k in range(K+1)]
minus=[[0 for j in range(K+1)] for k in range(K+1)]
for j in range(K+1):
dp[j][j]=1
plus[j][j]=1
minus[j][j]=1
for k in range(K+1):
for j in range(1,K+1):
plus[j][k]+=plus[j-1][k]
for j in range(K+1):
for k in range(1,K+1):
minus[j][k]+=minus[j][k-1]
for i in range(m-1,-1,-1):
ndp=[[0 for j in range(K+1)] for k in range(K+1)]
for k in range(min(b[i],K)+1):
for j in range(min(K,k+c[i])+1):
M=max(k-j,-a[i])
if max(0,M)+j==0:
ndp[j][k]+=plus[K][k]
else:
ndp[j][k]+=plus[K][k]-plus[(max(0,M))+j-1][k]
if min(K-k,-M)>0:
ndp[j][k]+=minus[j][k+min(K-k,-M)]-minus[j][k]
ndp[j][k]%=mod
dp=ndp
for j in range(K+1):
for k in range(K+1):
plus[j][k]=ndp[j][k]
minus[j][k]=ndp[j][k]
for k in range(K+1):
for j in range(1,K+1):
plus[j][k]=(plus[j][k]+plus[j-1][k])%mod
for j in range(K+1):
for k in range(1,K+1):
minus[j][k]=(minus[j][k]+minus[j][k-1])%mod
print((dp[0][0])) | p02635 |
def main():
mod = 998244353
s, k = input().split()
k = int(k)
n = len(s)
one = s.count("1")
cnt = 0
zero_list = []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
z = 0
dp = [[0]*(one+1) for _ in [0]*(one+1)]
dp[0][0] = 1
for i in range(len(zero_list)):
dp2 = [[0]*(min(one, k)+1) for _ in [0]*(one+1)]
base = zero_list[i]
# j:何個今までに入れたか
for j in range(one+1):
# l:何個入れるか
for l in range(one+1-j):
if j+l > one:
continue
if j+l < z+base:
continue
# p:これまでのペナルティ
for p in range(min(one, k)+1):
q = p+max(l-base, 0)
if q <= min(one, k) and j+l <= one:
dp2[j+l][q] = (dp2[j+l][q]+dp[j][p]) % mod
z += base
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main()
| def main():
mod = 998244353
s, k = input().split()
k = int(k)
n = len(s)
one = s.count("1")
cnt = 0
zero_list = []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
z = 0
mm = min(one, k)
dp = [[0]*(one+1) for _ in [0]*(one+1)]
dp[0][0] = 1
for i in range(len(zero_list)):
dp2 = [[0]*(mm+1) for _ in [0]*(one+1)]
base = zero_list[i]
# j:何個今までに入れたか
for j in range(one+1):
# l:何個入れるか
for l in range(one+1-j):
if l < z+base-j:
continue
ml = max(l-base, 0)
# p:これまでのペナルティ
for p in range(min(one, k)+1):
q = p+ml
if q <= mm:
dp2[j+l][q] = (dp2[j+l][q]+dp[j][p]) % mod
else:
break
z += base
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main() | p02635 |
def main():
mod = 998244353
s, k = input().split()
k = int(k)
n = len(s)
one = s.count("1")
cnt = 0
zero_list = []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
z = 0
mm = min(one, k)
dp = [[0]*(one+1) for _ in [0]*(one+1)]
dp[0][0] = 1
for i in range(len(zero_list)):
dp2 = [[0]*(mm+1) for _ in [0]*(one+1)]
base = zero_list[i]
# j:何個今までに入れたか
for j in range(one+1):
# l:何個入れるか
for l in range(one+1-j):
if l < z+base-j:
continue
ml = max(l-base, 0)
# p:これまでのペナルティ
for p in range(min(one, k)+1):
q = p+ml
if q <= mm:
dp2[j+l][q] = (dp2[j+l][q]+dp[j][p]) % mod
else:
break
z += base
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main() | def main():
mod = 998244353
s, k = input().split()
k, n, one, cnt, z, zero_list = int(k), len(s), s.count("1")+1, 0, 0, []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
mm = min(one-1, k)
dp = [[0]*(mm+1) for _ in [0]*one]
dp[0][0] = 1
for i in zero_list:
dp2 = [[0]*(mm+1) for _ in [0]*one]
for j in range(one):
for l in range(max(z+i-j, 0), one-j):
ml = max(l-i, 0)
for p in range(min(j, mm-ml)+1):
dp2[j+l][p+ml] = (dp2[j+l][p+ml]+dp[j][p]) % mod
z += i
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main() | p02635 |
def main():
mod = 998244353
s, k = input().split()
k, n, one, cnt, z, zero_list = int(k), len(s), s.count("1")+1, 0, 0, []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
mm = min(one-1, k)
ans = 0
dp = [[0]*(mm+1) for _ in [0]*one]
dp[0][0] = 1
for i in zero_list:
dp2 = [[0]*(mm+1) for _ in [0]*one]
for j in range(one):
for l in range(max(z+i-j, 0), one-j):
ml = max(l-i, 0)
for p in range(min(j, mm-ml)+1):
ans += 1
dp2[j+l][p+ml] = (dp2[j+l][p+ml]+dp[j][p]) % mod
z += i
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main()
| def main():
mod = 998244353
s, k = input().split()
k, n, one, cnt, z, zero_list = int(k), len(s), s.count("1")+1, 0, 0, []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
mm = min(one-1, k)
dp = [[0]*(mm+1) for _ in [0]*one]
dp[0][0] = 1
for i in zero_list:
dp2 = [[0]*(mm+1) for _ in [0]*one]
for jl in range(z+i, one):
for x in range(i, min(one, jl+1, mm+i+1)):
dp2[jl][x-i] = (dp2[jl][x-i]+sum([dp[jl-x+p][p]
for p in range(min(one, x-i+1))])) % mod
for p in range(min(one, mm+1)):
dp2[jl][p] = (dp2[jl][p]+sum([dp[jl-l][p]
for l in range(min(one, i, jl-p+1))])) % mod
z += i
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main()
| p02635 |
def main():
mod = 998244353
s, k = input().split()
k, n, one, cnt, z, zero_list = int(k), len(s), s.count("1")+1, 0, 0, []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
mm = min(one-1, k)
dp = [[0]*(mm+1) for _ in [0]*one]
dp[0][0] = 1
for i in zero_list:
dp2 = [[0]*(mm+1) for _ in [0]*one]
for jl in range(z+i, one):
for x in range(i, min(one, jl+1, mm+i+1)):
dp2[jl][x-i] = (dp2[jl][x-i]+sum([dp[jl-x+p][p]
for p in range(min(one, x-i+1))])) % mod
for p in range(min(one, mm+1)):
dp2[jl][p] = (dp2[jl][p]+sum([dp[jl-l][p]
for l in range(min(one, i, jl-p+1))])) % mod
z += i
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main()
| def main():
mod = 998244353
s, k = input().split()
k, n, o, cnt, z, zero_list = int(k), len(s), s.count("1")+1, 0, 0, []
for i in range(n):
if s[i] == "0":
zero_list.append(cnt)
cnt = 0
else:
cnt += 1
m = min(o, k+1)
dp = [[0]*m for _ in [0]*o]
dp[0][0] = 1
for i in zero_list:
dp2 = [[0]*m for _ in [0]*o]
dp3 = [[0] for _ in [0]*o]
for x in range(o):
t = 0
for y in range(min(m, o-x)):
t = (t+dp[x+y][y]) % mod
dp3[x].append(t)
dp4 = [[0]*m for _ in [0]*o]
for y in range(m):
t = dp[0][y]
for x in range(1, o):
dp4[x-1][y] = t
t = (t+dp[x][y]) % mod
dp4[o-1][y] = t
for j in range(z+i, o):
for x in range(min(j-i+1, m)):
dp2[j][x] = (dp2[j][x]+dp3[j-x-i][min(o, x+1)]) % mod
for p in range(m):
dp2[j][p] = (dp2[j][p]+dp4[j][p]-dp4[max(j-i, p-1)][p]) % mod
z += i
dp = dp2
print((sum([sum(i) for i in dp]) % mod))
main() | p02635 |
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
#a,b,c,d = map(int,readline().split())
s,k = readline().split()
a = [len(i) for i in s.split("0")]
while a and a[-1] == 0: a.pop()
if not a:
print((1))
exit()
MOD = 998244353
M = sum(a)+1
k = min(int(k),M)
dp = [[0]*M for _ in range(k+1)] # j 使って（上限 k）、l 余ってる
dp[0][0] = 1
#print(a)
for ai in a[::-1]:
ndp = [[0]*M for _ in range(k+1)] # j 使って（上限 k）、l 余ってる
for j in range(k+1):
for l in range(M):
for ll in range(l):
ndp[j][ll] += dp[j][l]
ndp[j][ll] %= MOD
V = min(M-l,k-j+1,ai+1)
for i in range(V):
#if j+i > k: break
ndp[j+i][l+i] += dp[j][l]
ndp[j+i][l+i] %= MOD
dp = ndp
#print(dp)
ans = 0
for jj in range(k+1):
ans += dp[jj][0]
print((ans%MOD))
| # coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
#a,b,c,d = map(int,readline().split())
s,k = readline().split()
a = [len(i) for i in s.split("0")]
while a and a[-1] == 0: a.pop()
if not a:
print((1))
exit()
MOD = 998244353
M = sum(a)+1
k = min(int(k),M)
dp = [[0]*M for _ in range(k+1)] # j 使って（上限 k）、l 余ってる
dp[0][0] = 1
#print(a)
for ai in a[::-1]:
ndp = [[0]*M for _ in range(k+1)] # j 使って（上限 k）、l 余ってる
for j in range(k+1):
for l in range(M):
if dp[j][l]:
for ll in range(l):
ndp[j][ll] += dp[j][l]
ndp[j][ll] %= MOD
V = min(M-l,k-j+1,ai+1)
for i in range(V):
#if j+i > k: break
ndp[j+i][l+i] += dp[j][l]
ndp[j+i][l+i] %= MOD
dp = ndp
#print(dp)
ans = 0
for jj in range(k+1):
ans += dp[jj][0]
print((ans%MOD))
| p02635 |
s,k = input().split()
K = int(k)
if s[-1] == "1":
s += "0"
n = len(s)
ls = []
cnt = 0
for i in range(n):
if s[i] == "0":
ls.append(cnt)
cnt = 0
else:
cnt += 1
l = len(ls)
sm = sum(ls)
mod = 998244353
dp = [[[0 for i in range(sm+1)] for j in range(sm+1)] for k in range(l+1)]
dp[0][0][0] = 1
smprv = 0
for i in range(1,l+1):
num = ls[i-1]
for j in range(smprv+num,sm+1):
if j == smprv+num:
dp[i][j][0] = 1
for k in range(1,j+1):
for m in range(j+1):
if num >= m:
dp[i][j][k] += dp[i-1][j-m][k]
else:
dp[i][j][k] += dp[i-1][j-m][k-(m-num)]
dp[i][j][k] %= mod
smprv += num
ans = 0
for i in range(sm+1):
if i <= K:
ans += dp[-1][-1][i]
ans %= mod
print(ans) | s,k = input().split()
K = int(k)
if s[-1] == "1":
s += "0"
n = len(s)
ls = []
cnt = 0
for i in range(n):
if s[i] == "0":
ls.append(cnt)
cnt = 0
else:
cnt += 1
l = len(ls)
sm = sum(ls)
mod = 998244353
dp = [[[0 for i in range(sm+1)] for j in range(sm+1)] for k in range(l+1)]
dp[0][0][0] = 1
smprv = 0
for i in range(1,l+1):
num = ls[i-1]
for j in range(smprv+num,sm+1):
if j == smprv+num:
dp[i][j][0] = 1
for k in range(1,j+1):
x = 0
for m in range(j+1):
if num >= m:
x += dp[i-1][j-m][k]
else:
x += dp[i-1][j-m][k-(m-num)]
dp[i][j][k] = x%mod
smprv += num
ans = 0
for i in range(sm+1):
if i <= K:
ans += dp[-1][-1][i]
ans %= mod
print(ans) | p02635 |
import sys
a, b, c, d = list(map(int, sys.stdin.readline().split()))
def main():
return 'Yes' if abs(c - a) <= d or abs(b - a) <= d and abs(c - b) <= d else 'No'
if __name__ == '__main__':
ans = main()
print(ans) | import sys
a, b, c, d = list(map(int, sys.stdin.readline().split()))
def main():
ans = 'No'
if abs(c - a) <= d: ans = 'Yes'
elif abs(b - a) <= d and abs(c - b) <= d: ans = 'Yes'
print(ans)
if __name__ == '__main__':
main() | p03351 |
a,b,c,d = list(map(int,input().split()))
if abs(a-c) <= d or (abs(a-b) <= d and abs(c-b) <= d):
print("Yes")
else:
print("No") | A,B,C,D = list(map(int,input().split()))
print(("Yes" if abs(A-C)<=D or abs(A-B)<=D and abs(B-C)<=D else "No")) | p03351 |
a,b,c,d=list(map(int, input().split()))
if (abs(a-c)<=d) or (abs(a-b)<=d) and (abs(b-c)<=d):
print('Yes')
else:
print('No') | a,b,c,d=list(map(int, input().split()))
print(("Yes" if (abs(a-c)<=d) or (abs(a-b)<=d) and (abs(b-c)<=d) else "No")) | p03351 |
a,b,c,d = list(map(int, input().split()))
if (a-c)**2<=d**2 or ((a-b)**2<=d**2 and (b-c)**2<=d**2):
print("Yes")
else:
print("No")
| a,b,c,d=list(map(int, input().split()))
print(("Yes" if abs(a-c)<=d or (abs(a-b)<=d and abs(b-c)<=d) else "No"))
| p03351 |
a, b, c, d = list(map(int, input().split()))
if abs(b - a) <= d and abs(c - b) <= d:
print("Yes")
elif abs(c - a) <= d:
print("Yes")
else:
print("No")
| a, b, c, d = list(map(int, input().split()))
if abs(a-b) <= d and abs(b-c) <= d:
print("Yes")
elif abs(a-c) <= d:
print("Yes")
else:
print("No")
| p03351 |
a, b, c, d = list(map(int, input().split()))
print(('Yes' if abs(c - a) <= d or abs(b - a) <= d and abs(c - b) <= d else 'No')) | a, b, c, d = list(map(int, input().split()))
if abs(c - a) <= d or abs(b - a) <= d and abs(c - b) <= d:
print('Yes')
else:
print('No') | p03351 |
a,b,c,d=list(map(int,input().split()))
print(("Yes" if abs(c-a)<=d or (abs(b-a)<=d and abs(c-b)<=d) else "No")) | a,b,c,d=list(map(int,input().split()))
print(("Yes" if abs(c-a)<=d or abs(b-a)<=d and abs(c-b)<=d else "No")) | p03351 |
a, b, c, d = list(map(int,input().split()))
# aとcの距離の絶対値ACを定義
if (a - c) >= 0:
AC = (a-c)
else:
AC = (c-a)
# BがAとCの間に入る場合のみ、AB間、BC間を定義
if a < b < c:
AB = (b - a)
BC = (c - b)
if c < b < a:
AB = (a-b)
BC = (b-c)
# AとCの距離がd以下ならYes！
if AC <= d:
print('Yes')
# AB間、BC間ともにd以下ならYes！
elif AB <= d and BC <= d:
print('Yes')
else:
print('No')
| a, b, c, d = list(map(int,input().split()))
# aとcの距離ACを定義
if (a - c) >= 0:
AC = (a-c)
else:
AC = (c-a)
# BがAとCの間に入る場合のみ、AB間、BC間を定義
if a < b < c:
AB = (b - a)
BC = (c - b)
if c < b < a:
AB = (a-b)
BC = (b-c)
# AとCの距離がd以下ならYes！
if AC <= d:
print('Yes')
# AB間、BC間ともにd以下ならYes！
elif AB <= d and BC <= d:
print('Yes')
else:
print('No') | p03351 |
a, b, c, d = list(map(int, input().split()))
print(("Yes" if abs(a-c) <= d or (abs(a-b) <= d and abs(b-c) <= d) else "No")) | a, b, c, d = list(map(int, input().split()))
if abs(a-c)<=d:
print('Yes')
elif not ((a<=b<=c)or(c<=b<=a)):
print('No')
else:
if (abs(a-b)<=d)and(abs(b-c)<=d):
print('Yes')
else:
print('No') | p03351 |
a,b,c,d = list(map(int,input().split()))
if (abs(b-a)<=d and abs(c-b)<=d) or abs(c-a)<=d:
print("Yes")
else:
print("No") | a,b,c,d = list(map(int,input().split()))
print(("YNeos"[(abs(a-b)>d or abs(b-c)>d) and abs(a-c)>d::2])) | p03351 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
n = I()
a = LI()
ma = n*(n+1)//2
su = sum(a)
s = [1 for i in range(n+1)]
for i in range(1,n):
s[i+1] = s[i]+n-i+1
d = [None for i in range(ma+1)]
d[0] = 0
k = 1
for i in range(1,n+1):
for j in range(n+1-i):
d[k+j] = i
k += n+1-i
k = n%2
dp = [su if (d[i]+k)%2 else -su for i in range(ma+1)]
dp[0] = 0
if k:
for i in range(n):
dp[i+1] = a[n-1-i]
else:
for i in range(n):
dp[i+1] = -a[n-1-i]
for i in range(1,ma):
r = n-1-(i-s[d[i]])
l = r+1-d[i]
j = i+(n-d[i])
j2 = j+1
if (d[i]+k)%2:
if r < n-1:
if a[r+1]+dp[i] > dp[j]:
dp[j] = a[r+1]+dp[i]
if l > 0:
if a[l-1]+dp[i] > dp[j2]:
dp[j2] = a[l-1]+dp[i]
else:
if r < n-1:
if -a[r+1]+dp[i] < dp[j]:
dp[j] = -a[r+1]+dp[i]
if l > 0:
if -a[l-1]+dp[i] < dp[j2]:
dp[j2] = -a[l-1]+dp[i]
print((dp[ma]))
return
#C
def C():
def comb(a,b):
return fact[a]*inv[b]*inv[a-b]%mod
n,k = LI()
a = LI()
"""
fact = [1]
for i in range(n+k):
fact.append(fact[-1]*(i+1)%mod)
inv = [1]*(n+k+1)
inv[n+k] = pow(fact[n+k],mod-2,mod)
for i in range(n+k)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
f = [comb(i+n-1,n-1) for i in range(k+1)]
for i in a:
for j in range(k-i)[::-1]:
f[j+i+1] -= f[j]
f[j+i+1] %= mod
print(f[k])
"""
dp = [[0]*(k+1) for i in range(n+1)]
for i in range(k+1):
dp[0][i] = 1
for i in range(n):
ni = i+1
ai = a[i]
for j in range(k+1):
if j >= ai+1:
dp[ni][j] = (dp[i][j]-dp[i][j-ai-1])%mod
else:
dp[ni][j] = dp[i][j]
if i < n-1:
for j in range(k):
dp[ni][j+1] += dp[ni][j]
dp[ni][j+1] %= mod
print((dp[n][k]%mod))
return
#D
def D():
n = I()
a = LI()
a.insert(0,0)
for i in range(n):
a[i+1] += a[i]
dp = [[0]*(n+1) for i in range(n)]
for le in range(1,n):
for l in range(n-le):
r = l+le+1
res = float("inf")
for i in range(l+1,r):
m = dp[l][i]+dp[i][r]
if m < res:
res = m
res += a[r]-a[l]
dp[l][r] = res
print((dp[0][n]))
return
#E
def E():
n = I()
a = LIR(n)
m = 1<<n
dp = [0]*m
dp[0] = 1
a = [[j for j in range(n) if a[i][j]] for i in range(n)]
bit_count = [0]
for i in range(n):
for j in range(len(bit_count)):
bit_count.append(bit_count[j]+1)
for k in range(1,m):
i = bit_count[k]-1
for j in a[i]:
bj = 1<<j
if bj > k:
break
if not k&bj:
continue
nk = k^bj
dp[k] += dp[nk]
print((dp[m-1]%mod))
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
E()
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
n,k = LI()
a = LI()
dp = [0 for i in range(k+1)]
f = [0 for i in range(k+1)]
for i in range(k+1):
if not f[i]:
for j in a:
if i-j >= 0:
dp[i] = 1-dp[i-j]
if dp[i] == 0:
break
else:
dp[i] = 1
print((["First","Second"][dp[k]]))
#B
def B():
n = I()
a = LI()
ma = n*(n+1)//2
su = sum(a)
s = [1 for i in range(n+1)]
for i in range(1,n):
s[i+1] = s[i]+n-i+1
d = [None for i in range(ma+1)]
d[0] = 0
k = 1
for i in range(1,n+1):
for j in range(n+1-i):
d[k+j] = i
k += n+1-i
k = n%2
dp = [su if (d[i]+k)%2 else -su for i in range(ma+1)]
dp[0] = 0
if k:
for i in range(n):
dp[i+1] = a[n-1-i]
else:
for i in range(n):
dp[i+1] = -a[n-1-i]
for i in range(1,ma):
r = n-1-(i-s[d[i]])
l = r+1-d[i]
j = i+(n-d[i])
j2 = j+1
if (d[i]+k)%2:
if r < n-1:
if a[r+1]+dp[i] > dp[j]:
dp[j] = a[r+1]+dp[i]
if l > 0:
if a[l-1]+dp[i] > dp[j2]:
dp[j2] = a[l-1]+dp[i]
else:
if r < n-1:
if -a[r+1]+dp[i] < dp[j]:
dp[j] = -a[r+1]+dp[i]
if l > 0:
if -a[l-1]+dp[i] < dp[j2]:
dp[j2] = -a[l-1]+dp[i]
print((dp[ma]))
return
#C
def C():
def comb(a,b):
return fact[a]*inv[b]*inv[a-b]%mod
n,k = LI()
a = LI()
"""
fact = [1]
for i in range(n+k):
fact.append(fact[-1]*(i+1)%mod)
inv = [1]*(n+k+1)
inv[n+k] = pow(fact[n+k],mod-2,mod)
for i in range(n+k)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
f = [comb(i+n-1,n-1) for i in range(k+1)]
for i in a:
for j in range(k-i)[::-1]:
f[j+i+1] -= f[j]
f[j+i+1] %= mod
print(f[k])
"""
dp = [[0]*(k+1) for i in range(n+1)]
for i in range(k+1):
dp[0][i] = 1
for i in range(n):
ni = i+1
ai = a[i]
for j in range(k+1):
if j >= ai+1:
dp[ni][j] = (dp[i][j]-dp[i][j-ai-1])%mod
else:
dp[ni][j] = dp[i][j]
if i < n-1:
for j in range(k):
dp[ni][j+1] += dp[ni][j]
dp[ni][j+1] %= mod
print((dp[n][k]%mod))
return
#D
def D():
n = I()
a = LI()
a.insert(0,0)
for i in range(n):
a[i+1] += a[i]
dp = [[0]*(n+1) for i in range(n)]
for le in range(1,n):
for l in range(n-le):
r = l+le+1
res = float("inf")
for i in range(l+1,r):
m = dp[l][i]+dp[i][r]
if m < res:
res = m
res += a[r]-a[l]
dp[l][r] = res
print((dp[0][n]))
return
#E
def E():
n = I()
a = LIR(n)
m = 1<<n
dp = [0]*m
dp[0] = 1
a = [[j for j in range(n) if a[i][j]] for i in range(n)]
bit_count = [-1]
for i in range(n):
for j in range(len(bit_count)):
bit_count.append(bit_count[j]+1)
for k in range(1,m):
i = bit_count[k]
for j in a[i]:
bj = 1<<j
if bj > k:
break
if not k&bj:
continue
nk = k^bj
dp[k] += dp[nk]
print((dp[m-1]%mod))
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
E()
| p03174 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=list(map(int,input().split()))
heikin=sum(l)/n
samunenum=100
samune=10**18
for i in range(n):
x=abs(heikin-l[i])
if x<samune:
samunenum=i
samune=x
print(samunenum)
resolve() | import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=list(map(int,input().split()))
samunenum=100
samune=10**18
for i in range(n):
x=abs(sum(l)-n*l[i])
if x<samune:
samunenum=i
samune=x
print(samunenum)
resolve() | p03214 |
def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
avg = sum(A)/N
ans = 0
mi = abs(A[0] - avg)
for i, a in enumerate(A[1:], start=1):
if abs(a - avg) < mi:
ans = i
mi = abs(a - avg)
print(ans)
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
avg = sum(A)/N
mi = abs(A[0] - avg)
idx = 0
for i, a in enumerate(A[1:], start=1):
if abs(a - avg) < mi:
mi = abs(a - avg)
idx = i
print(idx)
if __name__ == '__main__':
main()
| p03214 |
def main():
n = int(eval(input()))
a_list = list(map(int, input().split()))
mean_a = sum(a_list) / n
diff_list = [abs(a - mean_a) for a in a_list]
min_a = min(diff_list)
print((diff_list.index(min_a)))
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
a_list = list(map(int, input().split()))
sum_a = sum(a_list)
min_val = 100
min_index = 0
for i, a in enumerate(a_list):
d = abs(n * a - sum_a)
if d < min_val:
min_val = d
min_index = i
print(min_index)
if __name__ == "__main__":
main()
| p03214 |
n=int(eval(input()))
*a,=list(map(int,input().split()))
avg=sum(a)/n
c=[(abs(j-avg),i) for i,j in enumerate(a)]
c.sort(key=lambda x:(x[0],x[1]))
print((c[0][1])) | n=int(eval(input()))
*a,=list(map(int,input().split()))
avg=sum(a)/n
ans,m=0,1e22
for i,j in enumerate(a):
if abs(j-avg)<m:
ans=i
m=abs(j-avg)
print(ans) | p03214 |
n = int(eval(input()))
w = list(map(int,input().split()))
# s1とs2の差の絶対値の最小値が最小になる部分を中心として考えれば良い
# wの最大値と最小値を順々に足したものを比較すれば良い
s1 = []
s2 = []
while len(w)>0:
if sum(s1) <= sum(s2):
s1.append(w.pop(0))
else:
s2.append(w.pop(-1))
print((abs(sum(s1)-sum(s2))))
| n = int(eval(input()))
w = list(map(int, input().split()))
z = []
for i in range(n):
x = sum(w[:i])
y = sum(w[i:])
z.append(abs(x-y))
print((min(z))) | p03012 |
l = int(eval(input()))
ws = list(map(int, input().split()))
c = 9999
for i in range(l):
c = min([c, abs(sum(ws[i:])- sum(ws[:i]))])
print(c)
| l = int(eval(input()))
ws = list(map(int, input().split()))
print((min([abs(sum(ws[i:]) - sum(ws[:i])) for i in range(l)])))
| p03012 |
n = int(eval(input()))
w = list(map(int, input().split()))
a = 10**19
for i in range(1, n-1):
a = min(abs(sum(w[:i+1]) - sum(w[i+1:])), a)
print(a)
| # 問題が少しわかりずらい。
n = int(eval(input()))
w = list(map(int, input().split()))
a = 10**19
for i in range(1, n-1):
# 重りを二つに分け、差異の最小値を判定する。
a = min(abs(sum(w[:i+1]) - sum(w[i+1:])), a)
print(a)
| p03012 |
n = int(eval(input()))
l = list(map(int, input().split()))
print((min(abs(sum(l[:i])-sum(l[i:])) for i in range(1,n)))) | eval(input())
l=list(map(int,input().split()))
s=sum(l)
a,t=s,0
for i in l: t+=i; a=min(a,abs(s-t*2))
print(a) | p03012 |
# B - Balance
n = int(eval(input()))
w = list(int(x) for x in input().split())
ans = 10**6
for i in range(1, n):
ans = min(ans, abs(sum(w[:i]) - sum(w[i:])))
print(ans) | # B - Balance
n = int(eval(input()))
w = list(int(x) for x in input().split())
wsum = [0]
for i in range(n):
wsum.append(wsum[i] + w[i])
ans = 10**6
for i in range(1, n):
ans = min(ans, abs(wsum[n]-wsum[i]-wsum[i]))
print(ans)
| p03012 |
N = int(eval(input()))
W = list(map(int, input().split()))
l = []
for T in range(N):
sum1 = sum(W[:T+1])
sum2 = sum(W[T+1:])
d = abs(sum1-sum2)
l.append(d)
print((min(l))) | N = int(eval(input()))
W = list(map(int, input().split()))
l = []
for T in range(N):
sum1 = sum(W[:T])
sum2 = sum(W[T:])
d = abs(sum1-sum2)
l.append(d)
print((min(l))) | p03012 |
N = int(eval(input()))
W = list(map(int, input().split()))
ww = []
for i in range(N):
ww.append(sum(W[0:i+1]))
ans = [abs((2 * q) - ww[N-1]) for q in ww]
print((min(ans))) | N = int(eval(input()))
W = list(map(int, input().split()))
ans = [abs(sum(W[0:i+1]) - sum(W[i+1:])) for i in range(N-1)]
print((min(ans)))
| p03012 |
# 129 B
n = int(eval(input()))
l = list(map(int, input().split()))
diff = (100 ** 100)
for t in range(len(l)):
s1 = 0
s2 = 0
for i in range(len(l)):
if i <= t:
s1 += l[i]
else:
s2 += l[i]
x = abs(s2 - s1)
if x <= diff:
diff = x
print(diff)
| n = int(eval(input()))
w = list(map(int, input().split()))
p = [0 for i in range(n)]
p[0] = w[0]
for i in range(1, n):
p[i] = p[i-1] + w[i]
diff = float('inf')
for j in range(n):
cd = abs(p[n-1] - (2*p[j]))
diff = min(diff, cd)
print(diff) | p03012 |
n = int(eval(input()))
w = list(map(int, input().split()))
ans = 10000000000
for t in range(1, n):
left, right = 0, 0
for i in range(t):
left += w[i]
for i in range(t, n):
right += w[i]
ans = min(ans, abs(left - right))
print(ans)
| n = int(eval(input()))
w = list(map(int, input().split()))
ans = 10000000000
for t in range(1, n):
left = sum(w[:t])
right = sum(w[t:])
ans = min(ans, abs(left - right))
print(ans)
| p03012 |
N = int(eval(input()))
W = list(map(int, input().split()))
# O(N^2)で解いても間に合う
m = 10**10
for i in range(1, N):
a, b = 0, 0
for j in range(i):
a += W[j]
for j in range(i, N):
b += W[j]
m = min(m, abs(a-b))
print(m) | N = int(eval(input()))
W = list(map(int, input().split()))
# 累積和 => O(N)
S = [0] * N
S[0] = W[0]
for i in range(N-1):
S[i+1] = S[i] + W[i+1]
# S[0] = W[0]
# S[1] = W[0] + W[1]
# S[2] = W[0] + W[1] + W[2]
# S[N-1] = W[0] + W[1] + ... + W[N-1]
# S[i] = W[0] + ... + W[i]
# S[N-1] - S[i] = W[i+1] + ... + W[N-1]
m = 10**10
for i in range(N-1):
m = min(m, abs(S[N-1] - 2*S[i]))
print(m) | p03012 |
n = int(eval(input()))
w = list(map(int, input().split()))
ans = 10 ** 9
for t in range(n):
cnt = 0
for i in range(n):
a = 1
if i > t:
a = -1
cnt += a * w[i]
ans = min(ans, abs(cnt))
print(ans) | n = int(eval(input()))
w = list(map(int, input().split()))
ans = 10 ** 9
now = sum(w)
for i in range(n):
now -= 2 * w[i]
ans = min(ans, abs(now))
print(ans) | p03012 |
n = int(eval(input()))
lst = list(map(int,input().split()))
lst2 = [0]*n
all_sum = 0
for e in lst:
all_sum += e
for i in range(n):
for j in range(i+1):
lst2[i] += lst[j]
for before,now in zip(lst2,lst2[1:]):
if abs(abs(now-all_sum)-abs(now))<abs(abs(before-all_sum)-abs(before)):
ans = abs(abs(now-all_sum)-abs(now))
else:break
print(ans)
|
n = int(eval(input()))
lst = list(map(int,input().split()))
ans = None
for t in range(n-1):
left = [x for x in lst[:t+1]]#t+1未満まで
right = [x for x in lst[t+1:]]#t＋1以上
sum_left=0
for e in left:
sum_left+=e
sum_right=0
for e in right:
sum_right+=e
if ans==None or abs(sum_left-sum_right)<ans:
ans = abs(sum_left-sum_right)
else:break
print(ans)
| p03012 |
n = int(eval(input()))
w = list(map(int, input().split()))
l =[]
for i in range(n):
l.append(abs(sum(w[:i]) - sum(w[i:])))
print((min(l))) | n = int(eval(input()))
w = list(map(int, input().split()))
ans = 10000
for i in range(n):
s = abs(sum(w[:i]) - sum(w[i:]))
ans = min(s,ans)
print(ans)
| p03012 |
import sys
stdin = sys.stdin
mod = 1000000007
inf = 1 << 60
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()
n = ni()
w = na()
ans = inf
d = [0] * (n + 1)
b = [0] * (n + 1)
for i in range(1, n + 1):
d[i] = w[i - 1] + d[i - 1]
b[i] = w[n - i] + b[i - 1]
b.reverse()
for i in range(1, n):
ans = min(ans, abs(d[i] - b[i]))
print(ans)
| import sys
stdin = sys.stdin
mod = 1000000007
inf = 1 << 60
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()
n = ni()
w = na()
ans = inf
s = sum(w)
p = 0
for i in range(n):
p += w[i]
ans = min(ans, abs(s - p - p))
print(ans) | p03012 |
n=int(eval(input()))
a=list(map(int,input().split()))
mini=float('inf')
sum1=0
sum2=sum(a)
t=0
while t<10**7:
t+=1
for i in range(n):
sum1=sum1+a[i]
sum2=sum2-a[i]
mini=min(mini,abs(sum1-sum2))
print(mini) | n=int(eval(input()))
a=list(map(int,input().split()))
mini=float('inf')
sum1=0
sum2=sum(a)
t=0
while t<n:
sum1=sum1+a[t]
sum2=sum2-a[t]
mini=min(mini,abs(sum1-sum2))
t+=1
print(mini) | p03012 |
n = int(eval(input()))
arr = list(map(int, input().split()))
dic = {}
for i in range(1,n+1):
S1 = sum(arr[:i])
S2 = sum(arr[i:])
dic[i] = abs(S1-S2)
ans = sorted(list(dic.items()), key=lambda x:x[1])
print((ans[0][1]))
| N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1<<60
for t in range(1, N):
L = sum(A[:t])
R = sum(A[t:])
ans = min(ans, abs(L-R))
print(ans)
| p03012 |
x = 10**9
n = int(eval(input()))
w = list(map(int,input().split()))
for i in range(n):
g,t = 0,0
for j in range(i):
g+=w[j]
for k in range(n-i):
t+=w[n-k-1]
x = min(x,abs(g-t))
print(x) | n = int(eval(input()))
a = list(map(int,input().split()))
s,g = sum(a),0
ans = s
for i in a:
g+=i
s-=i
ans = min(ans,abs(s-g))
print(ans) | p03012 |
n = int(eval(input()))
lst_W = list(map(int, input().split()))
ans = 999
for t in range(n):
low = sum(lst_W[:t])
high = sum(lst_W[t:])
if ans > abs(high - low):
ans = abs(high - low)
print(ans) | n = int(eval(input()))
w_lst = list(map(int, input().split()))
min = 1000000
for i in range(1, n):
s1 = sum(w_lst[:i])
s2 = sum(w_lst[i:])
if abs(s1 - s2) < min:
min = abs(s1 - s2)
print(min) | p03012 |
n = int(eval(input()))
lst = [int(i) for i in input().split()]
for i in range(n):
s1=0
for j in range(i):
s1+=lst[j]
s2=sum(lst)-s1
if i==0:
ans=abs(s1-s2)
elif abs(s1-s2)<ans:
ans=abs(s1-s2)
print(ans) | n = int(eval(input()))
lst = list(map(int,input().split()))
ans = 10**9
for i in range(n-1):
ans = min(ans,abs(sum(lst[:i+1])-sum(lst[i+1:])))
print(ans) | p03012 |
# coding: utf-8
# Your code here!
N = int(eval(input()))
W = list(map(int,input().split()))
S = sum(W)
ans = float('inf')
for i in range(1,N):
l = sum(W[:i+1])
r = S - l
ans = min(ans, abs(l-r))
print(ans) | # coding: utf-8
# Your code here!
N = int(eval(input()))
W = list(map(int,input().split()))
S = sum(W)
ans = float('inf')
for i in range(N):
l = sum(W[:i+1])
r = S - l
ans = min(ans, abs(l-r))
print(ans) | p03012 |
# -*- coding: utf-8 -*-
n=int(eval(input()))
W=list(map(int,input().split()))
t=0
while sum(W[:t])<sum(W[t:]) and t<n:
t=t+1
print((min(abs(sum(W[:t])-sum(W[t:])),abs(sum(W[:t-1])-sum(W[t-1:]))))) | # -*- coding: utf-8 -*-
n=int(eval(input()))
W=list(map(int,input().split()))
for i in range(n):
if sum(W[:i])>sum(W[i:]) or i==n-1:
print((min(sum(W[i-1:])-sum(W[:i-1]),sum(W[:i])-sum(W[i:]))))
break | p03012 |
from itertools import accumulate
N = int(eval(input()))
W = list(accumulate([int(x) for x in input().split()]))
ans = 10**9
for i in range(N - 1):
ans = min(ans, abs(W[N - 1] - W[i]*2))
print(ans) | N = int(eval(input()))
W = [int(x) for x in input().split()]
s1 = 0
s2 = sum(W)
ans = 10**9
for w in W:
s1 += w
s2 -= w
ans = min(ans, abs(s1 -s2))
print(ans)
| p03012 |
from collections import deque
n = int(eval(input()))
w = list(map(int,input().split()))
d = deque(w)
s1 = d.popleft()
s2 = d.pop()
for _ in range(n-2):
if s1 < s2:
s1 += d.popleft()
else:
s2 += d.pop()
print((abs(s1 - s2)))
| n = int(eval(input()))
w = list(map(int,input().split()))
ans = []
for i in range(1,n):
ans.append(abs(sum(w[:i])-sum(w[i:])))
print((min(ans)))
| p03012 |
N = int(eval(input()))
W = list(map(int, input().split()))
ans = float('inf')
for T in range(1, N):
ans = min(ans, abs(sum(W[T:])-sum(W[:T])))
print(ans) | n = int(eval(input()))
W = list(map(int, input().split()))
ans = float('inf')
for T in range(1, n):
ans = min(ans, abs(sum(W[:T])-sum(W[T:])))
print(ans) | p03012 |
n = int(eval(input()))
w = list(map(int, input().split()))
min_diff = 1000
for i in range(n):
diff = abs(sum(w[0:i]) - sum(w[i:]))
if diff < min_diff:
min_diff = diff
print(min_diff) | N = int(eval(input()))
W = list(map(int, input().split()))
ans = 1000
for i in range(N):
mi = abs(sum(W[0:i]) - sum(W[i:]))
if mi < ans:
ans = mi
print(ans)
| p03012 |
n = int(eval(input()))
l = list(map(int, list(input().split())))
s = sum(l)
temp = 0
if n == 2:
print((abs(l[-1] - l[0])))
exit(0)
for i in range(n):
if temp >= s - temp:
print((
min(abs(2*temp-s), abs(2*(temp-l[i-1])-s))
))
exit(0)
temp += l[i]
print((abs(2*l[-1]-s)))
| l=int(eval(input()))
b=[int(i) for i in input().split()]
print((sorted(abs(sum(b[i:])-sum(b[:i])) for i in range(0,l))[0])) | p03012 |
n = int(eval(input()))
x = list(map(int, input().split()))
left = 0
right = 0
for i in x:
right += i
reco = []
i = 0
while right > left:
left += x[i]
right -= x[i]
i += 1
reco.append(right - left)
reco[-1] = 0-reco[-1]
print((min(reco)))
| n = int(eval(input()))
x = list(map(int, input().split()))
left = 0
right = 0
for i in x:
right += i
reco = 0
i = 0
while right > left:
left += x[i]
right -= x[i]
i += 1
if right <= left:
print((min(reco, 0-(right - left))))
break
else:
reco = right - left
| p03012 |
N = int(eval(input()))
W = list(map(int, input().split()))
ttl = sum(W)
s = []
min = ttl
for i in range(len(W)):
s.append(W[i])
s2 = ttl - sum(s)
if abs(sum(s) - s2) < min:
min = abs(sum(s) - s2)
print(min) | N = int(eval(input()))
W = list(map(int, input().split()))
ttl = sum(W)
for i in range(len(W)):
ttl = min(ttl, abs(sum(W[:i]) - sum(W[i:])))
print(ttl) | p03012 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.