input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
readline = sys.stdin.readline
def root(x):
if uf[x] == x:
return x
else:
uf[x] = root(uf[x])
return uf[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
rx = root(x)
ry = root(y)
if rx == ry:
return
uf[rx] = ry
N, M = list(map(int,readline().split()))
p = list(map(int,readline().split()))
p.insert(0, -1)
uf = [i for i in range(N+1)]
for i in range(M):
a, b = (list(map(int,readline().split())))
unite(a, b)
for i in range(1, N+1):
root(i)
ans = 0
N += 1
match = [[] for i in range(N)]
for i in range(1, N):
match[uf[i]].append(i)
for i in range(1, N):
matchlen = len(match[i])
for j in range(matchlen):
if p[match[i][j]] in match[i]:
ans += 1
print((str(ans))) | import sys
readline = sys.stdin.readline
def root(x):
if uf[x] == x:
return x
else:
uf[x] = root(uf[x])
return uf[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
rx = root(x)
ry = root(y)
if rx == ry:
return
uf[rx] = ry
N, M = list(map(int,readline().split()))
p = list(map(int,readline().split()))
p.insert(0, -1)
uf = [i for i in range(N+1)]
for i in range(M):
a, b = (list(map(int,readline().split())))
unite(a, b)
for i in range(1, N+1):
root(i)
ans = 0
#N += 1
#match = [[] for i in range(N)]
#for i in range(1, N):
# match[uf[i]].append(i)
#for i in range(1, N):
# matchlen = len(match[i])
# for j in range(matchlen):
# if p[match[i][j]] in match[i]:
# ans += 1
for i in range(1, N+1):
if same(i, p[i]):
ans += 1
print((str(ans))) | p03354 |
import sys
readline = sys.stdin.readline
def root(x):
if uf[x] == x:
return x
else:
uf[x] = root(uf[x])
return uf[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
rx = root(x)
ry = root(y)
if rx == ry:
return
uf[rx] = ry
N, M = list(map(int,readline().split()))
p = list(map(int,readline().split()))
p.insert(0, -1)
uf = [i for i in range(N+1)]
for i in range(M):
a, b = (list(map(int,readline().split())))
unite(a, b)
for i in range(1, N+1):
root(i)
ans = 0
#N += 1
#match = [[] for i in range(N)]
#for i in range(1, N):
# match[uf[i]].append(i)
#for i in range(1, N):
# matchlen = len(match[i])
# for j in range(matchlen):
# if p[match[i][j]] in match[i]:
# ans += 1
for i in range(1, N+1):
if same(i, p[i]):
ans += 1
print((str(ans))) | import sys
readline = sys.stdin.readline
def root(x):
if uf[x] == x:
return x
else:
uf[x] = root(uf[x])
return uf[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
rx = root(x)
ry = root(y)
if rx == ry:
return
uf[rx] = ry
N, M = list(map(int,readline().split()))
p = list(map(int,readline().split()))
p.insert(0, -1)
uf = [i for i in range(N+1)]
for i in range(M):
a, b = (list(map(int,readline().split())))
unite(a, b)
for i in range(1, N+1):
root(i)
ans = 0
#戒めコード
#N += 1
#match = [[] for i in range(N)]
#for i in range(1, N):
# match[uf[i]].append(i)
#for i in range(1, N):
# matchlen = len(match[i])
# for j in range(matchlen):
# if p[match[i][j]] in match[i]:
# ans += 1
for i in range(1, N+1):
if same(i, p[i]):
ans += 1
print((str(ans)))
#root(i)=root(j)ならばiとjは行き来できる(iはjの居る場所に到達できる)
#知りたいのはiがp[i]のいる位置に来れるかどうか
#root(i)=root(p[i])なら,iはp[i]の位置に来れる,すなわちi番目にiを持ってくることができる | p03354 |
# D - Equals
from collections import deque
N, M = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
neighbor = [[] for _ in range(N)]
for idx in range(M):
neighbor[xy[idx][0]-1].append(xy[idx][1]-1)
neighbor[xy[idx][1]-1].append(xy[idx][0]-1)
can_swap = []
visited = [-1]*N
for start in range(N):
if visited[start] == -1:
tmp = [start] # startから到達可能なpointのリスト
d = deque([start])
while d:
current_point = d.pop()
visited[current_point] = 1
for next_point in neighbor[current_point]:
if visited[next_point] == -1:
d.append(next_point)
tmp.append(next_point)
can_swap.append(tmp)
ans = 0
for idx_group in can_swap:
tmp_p = [p[idx]-1 for idx in idx_group]
ans += len(set(tmp_p) & set(idx_group))
print(ans) | # D - Equals Union Find
N, M = list(map(int, input().split()))
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
# 負ならそのノードが根かつ絶対値が木の要素数を示す、正なら値のノードが根であることを示す
root = [-1] * N
# 木の高さを示す
rank = [1] * N
# インデックスxを与えると、xの根を返す関数
def find_root(x):
if root[x] < 0:
return x
else:
root[x] = find_root(root[x])
return root[x]
# インデックスx,yを与えると、xとyの木を統合する関数
def union(x,y):
# root_x, root_yは根のインデックス
root_x = find_root(x)
root_y = find_root(y)
if root_x == root_y:
return
elif rank[root_x] > rank[root_y]: # 短い木(yの方)を長い木(xの方)に繋ぐ
root[root_x] += root[root_y] # 要素数結合
root[root_y] = root_x # 根を切り替え
else:
root[root_y] += root[root_x]
root[root_x] = root_y
if rank[root_x] == rank[root_y]:
rank[root_y] += 1 # 新しい木の高さを1追加
for idx in range(M):
union(xy[idx][0]-1, xy[idx][1]-1)
ans = 0
for i in range(N):
if find_root(i) == find_root(p[i]-1):
ans += 1
print(ans) | p03354 |
n, m = list(map(int, input().split()))
ps = list(map(int, input().split()))
ls = [list(map(int, input().split())) for _ in range(m)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n + 1))
self.ranks = [0 for _ in range(n + 1)]
def get_root(self, x):
if self.parents[x] == x:
return x
self.parents[x] = self.get_root(self.parents[x])
return self.parents[x]
def merge(self, x, y):
x = self.get_root(x)
y = self.get_root(y)
if x != y:
if self.ranks[x] < self.ranks[y]:
self.parents[x] = y
else:
self.parents[y] = x
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
uf = UnionFind(n)
for a, b in ls:
uf.merge(a, b)
for i in range(1, n + 1):
uf.get_root(i)
cs = uf.parents
s0 = {c: [] for c in set(cs[1:])}
s1 = {c: [] for c in set(cs[1:])}
for i in range(1, n + 1):
c = cs[i]
s0[c].append(ps[i - 1])
s1[c].append(i)
res = 0
for c in set(cs[1:]):
res += len(set(s0[c]) & set(s1[c]))
print(res) | n, m = list(map(int, input().split()))
ps = list(map(int, input().split()))
ls = [list(map(int, input().split())) for _ in range(m)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n + 1))
self.ranks = [0 for _ in range(n + 1)]
def get_root(self, x):
if self.parents[x] == x:
return x
self.parents[x] = self.get_root(self.parents[x])
return self.parents[x]
def merge(self, x, y):
x = self.get_root(x)
y = self.get_root(y)
if x != y:
if self.ranks[x] < self.ranks[y]:
self.parents[x] = y
else:
self.parents[y] = x
if self.ranks[x] == self.ranks[y]:
self.ranks[x] += 1
uf = UnionFind(n)
for a, b in ls:
uf.merge(a, b)
res = 0
for i in range(1, n + 1):
p0 = uf.get_root(i)
p1 = uf.get_root(ps[i - 1])
if p0 == p1:
res += 1
print(res) | p03354 |
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 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 all_group_members(self):
return {r: self.members(r) for r in self.roots()}
n,m = list(map(int,input().split()))
P = list(map(int,input().split()))
uf = UnionFind(n)
for i in range(m):
a,b = list(map(int,input().split()))
uf.union(a-1,b-1)
values = list(uf.all_group_members().values())
ans = 0
for vs in values:
s = set(P[v]-1 for v in vs)
ans += len(s & (set(vs)))
print(ans) | ## TLE
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)
n,m = list(map(int,input().split()))
P = list(map(int,input().split()))
uf = UnionFind(n)
for i in range(m):
a,b = list(map(int,input().split()))
uf.union(a-1,b-1)
ans = 0
for i in range(n):
if uf.same(P[i]-1,i):
ans += 1
print(ans) | p03354 |
N, M = list(map(int, input().split()))
p = [int(i) for i in input().split()]
graph = [[] for _ in range(N+1)]
group = [0]*(N+1)
ans = 0
for _ in range(M):
x, y = (int(i) for i in input().split())
graph[x].append(y)
graph[y].append(x)
for i, num in enumerate(p, 1):
space = [i]
for point in space:
if group[point]:
continue
group[point] = i
space.extend(graph[point])
ans += (group[num] == group[i])
print(ans) | N, M = list(map(int, input().split()))
p = [int(i) for i in input().split()]
graph = [[] for _ in range(N+1)]
group = [0]*(N+1)
ans = 0
for _ in range(M):
x, y = list(map(int, input().split()))
graph[x].append(y)
graph[y].append(x)
for i, num in enumerate(p, 1):
space = [i]
for point in space:
if not group[point]:
group[point] = i
space.extend(graph[point])
ans += (group[num] == group[i])
print(ans) | p03354 |
def main():
n, m = list(map(int, input().split()))
p = [0] + list(map(int, input().split()))
cnt = 0
global parent
parent = list(range(n+1))
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if root(i) == root(p[i]):
cnt += 1
print(cnt)
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
root_x = root(x)
if root_x != root(y):
parent[root_x] = y
if __name__ == "__main__":
main() | def main():
n, m = list(map(int, input().split()))
p = [0] + list(map(int, input().split()))
cnt = 0
global parent
parent = list(range(n+1))
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i]):
cnt += 1
print(cnt)
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
root_x = root(x)
if root_x != root(y):
parent[root_x] = y
def same(x, y):
return root(x) == root(y)
if __name__ == "__main__":
main() | p03354 |
def main():
p = [0] + list(map(int, input().split()))
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i]):
cnt += 1
print(cnt)
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
root_x = root(x)
if root_x != root(y):
parent[root_x] = y
def same(x, y):
return root(x) == root(y)
if __name__ == "__main__":
n, m = list(map(int, input().split()))
parent = list(range(n+1))
main() | def main():
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i-1]):
cnt += 1
print(cnt)
def root(x):
if par[x] == x:
return x
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:
par[x] = y
if __name__ == "__main__":
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
par = [0] + [i for i in range(1, n+1)]
main()
| p03354 |
def main():
p = [0] + list(map(int, input().split()))
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i]):
cnt += 1
print(cnt)
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x, y):
root_x = root(x)
if root_x != root(y):
par[root_x] = y
def same(x, y):
return root(x) == root(y)
if __name__ == "__main__":
n, m = list(map(int, input().split()))
par = list(range(n+1))
main() | def main():
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i-1]):
cnt += 1
print(cnt)
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x, y):
root_x = root(x)
if root_x != root(y):
par[root_x] = y
def same(x, y):
return root(x) == root(y)
if __name__ == "__main__":
n, m = list(map(int, input().split()))
par = list(range(n+1))
p = list(map(int, input().split()))
main() | p03354 |
def main():
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i-1]):
cnt += 1
print(cnt)
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x, y):
x = root(x)
if x != root(y):
par[x] = y
def same(x, y):
return root(x) == root(y)
if __name__ == "__main__":
n, m = list(map(int, input().split()))
par = list(range(n+1))
p = list(map(int, input().split()))
main() | def main():
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i in range(1, n+1):
if same(i, p[i]):
cnt += 1
print(cnt)
def root(x):
if par[x] == x:
return x
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:
par[x] = y
if __name__ == "__main__":
n, m = list(map(int, input().split()))
p = [0] + list(map(int, input().split()))
par = list(range(n+1))
main()
| p03354 |
def main():
cnt = 0
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
if __name__ == "__main__":
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n+1))
rank = [0]*(n+1)
main()
| def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n+1))
rank = [0]*(n+1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| p03354 |
import sys
input = sys.stdin.buffer.readline
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n+1))
rank = [0]*(n+1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n+1))
rank = [0]*(n+1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] > rank[y]:
parent[y] = x
elif rank[x] < rank[y]:
parent[x] = y
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
unite(x, y)
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| p03354 |
n,m=list(map(int,input().split()))
f=lambda x:int(x)-1
p=list(map(f,input().split()))
par=[j for j in range(n)]
def find(x):
if x==par[x]:
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
ra=find(a)
rb=find(b)
if ra!=rb:
par[ra]=par[rb]
for i in range(m):
v,w=list(map(f,input().split()))
union(v,w)
ans=0
for j in range(n):
if find(j)==find(p[j]):
ans+=1
print(ans) | n,m=list(map(int,input().split()))
p=list(map(int,input().split()))
par=[i for i in range(n)]
def find(x):
if par[x]==x:
return par[x]
else:
par[x]=find(par[x])
return par[x]
def union(x,y):
fx=find(x)
fy=find(y)
if fx!=fy:
par[fx]=fy
f=lambda x:int(x)-1
for mm in range(m):
x,y=list(map(f,input().split()))
union(x,y)
ans=0
for i in range(n):
if find(p[i]-1)==find(i):
ans+=1
print(ans) | p03354 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
p = list( map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def root(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.root(x)
y = self.root(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.root(x)]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def members(self, x):
root = self.root(x)
return [i for i in range(self.n) if self.root(i) == root]
def all_roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.all_roots())
def all_group_members(self):
return {r: self.members(r) for r in self.all_roots()}
def __str__(self):
return ''.join('{}: {}'.format(r, self.members(r)) for r in self.all_roots())
uf = UnionFind(n)
ab = [tuple(map(int,input().split())) for i in range(m)]
for a,b in ab:
a,b = a-1,b-1
if uf.is_same(a,b): continue
uf.union(a,b)
ans = 0
for r in uf.all_roots():
if uf.size(r) == 1:
if p[r]-1 == r: ans += 1
else:
loop = set(uf.members(r))
member = {p[l]-1 for l in loop}
ans += len(set(loop) & set(member))
print(ans)
|
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
p = list( map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def root(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.root(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.root(x)
y = self.root(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.root(x)]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def members(self, x):
root = self.root(x)
return [i for i in range(self.n) if self.root(i) == root]
def all_roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.all_roots())
def all_group_members(self):
return {r: self.members(r) for r in self.all_roots()}
def __str__(self):
return ''.join('{}: {}'.format(r, self.members(r)) for r in self.all_roots())
uf = UnionFind(n)
ab = [tuple(map(int,input().split())) for i in range(m)]
for a,b in ab:
a,b = a-1,b-1
if uf.is_same(a,b): continue
uf.union(a,b)
ans = 0
loop = [set() for i in range(n)]
for i in range(n):
r = uf.root(i)
loop[r].add(i)
for i in range(n):
for j in loop[i]:
if p[j]-1 in loop[i]: ans += 1
print(ans)
| p03354 |
def d_equals(N, M, P, S):
class UnionFind(object):
def __init__(self, N):
self.p = list(range(N)) # 初期状態ではi番の頂点の親(parent)はi番
self.rank = [0] * N # 初期状態では全頂点がランク0(何もつながってない)
self.size = [1] * N # 初期状態ではどの頂点も連結成分の大きさは1
def find(self, x): # 頂点xが属する連結成分の代表(根の番号)を求める
if self.p[x] != x: # 頂点xの代表は他の頂点だった
self.p[x] = self.find(self.p[x]) # 経路圧縮(xを代表につなぐ)
return self.p[x]
def is_same(self, x, y): # 頂点x,yは同じ連結成分に属するか？
return self.find(x) == self.find(y)
def union(self, x, y): # x,yを同じ連結成分に属させる
u = self.find(x)
v = self.find(y)
if u == v: # x,yは既に同じ連結成分に属していた
return
if self.rank[u] < self.rank[v]:
self.p[u] = v # ランクの大きな方につなげる
self.size[v] += self.size[u] # つながっている要素数だけ足す
self.size[u] = 0 # ランクが小さかった連結成分は「解散」
else:
# 上と同様にやる
self.p[v] = u
self.size[u] += self.size[v]
self.size[v] = 0
if self.rank[u] == self.rank[v]:
# 根の分だけ1個「ずれる」
self.rank[u] += 1
ans = 0
uf = UnionFind(N)
for a, b in S:
uf.union(a - 1, b - 1) # Pのa番とb番は繋がっている(0-indexed)
for i in range(N):
if uf.is_same(P[i] - 1, i):
# 2つが同じ連結成分にあるなら、何回かswapしてp_i=iにできる
# 最初からp_i=iの場合、unionしてなくてもこの条件は成立
ans += 1
return ans
N,M = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(M)]
print((d_equals(N, M, P, S))) | def d_equals(N, M, P, S):
class UnionFind(object):
def __init__(self, N):
self.p = list(range(N)) # 初期状態ではi番の頂点の親(parent)はi番
self.rank = [0] * N # 初期状態では全頂点がランク0(何もつながってない)
self.size = [1] * N # 初期状態ではどの頂点も連結成分の大きさは1
def find(self, x): # 頂点xが属する連結成分の代表(根の番号)を求める
if self.p[x] != x: # 頂点xの代表は他の頂点だった
self.p[x] = self.find(self.p[x]) # 経路圧縮(xを代表につなぐ)
return self.p[x]
def is_same(self, x, y): # 頂点x,yは同じ連結成分に属するか？
return self.find(x) == self.find(y)
def union(self, x, y): # x,yを同じ連結成分に属させる
u = self.find(x)
v = self.find(y)
if u == v: # x,yは既に同じ連結成分に属していた
return
if self.rank[u] < self.rank[v]:
self.p[u] = v # ランクの大きな方につなげる
self.size[v] += self.size[u] # つながっている要素数だけ足す
self.size[u] = 0 # ランクが小さかった連結成分は「解散」
else:
# 上と同様にやる
self.p[v] = u
self.size[u] += self.size[v]
self.size[v] = 0
if self.rank[u] == self.rank[v]:
# 根の分だけ1個「ずれる」
self.rank[u] += 1
def get_size(self, x): # 頂点xが属する連結成分の大きさ
return self.size[self.find(x)]
def show(self):
return self.p
p = [0] + P
ans = 0
uf = UnionFind(N + 1)
for a, b in S:
uf.union(a, b) # Pのa番とb番は繋がっている
for i in range(1, N + 1):
if uf.is_same(p[i], i):
# 2つが同じ連結成分に属するなら何回かswapしてp_i=iにできる
# 最初からp_i=iの場合、unionしてなくてもこの条件は成立
ans += 1
return ans
N,M = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(M)]
print((d_equals(N, M, P, S))) | p03354 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class UnionFind:
# Reference: https://note.nkmk.me/python-union-find/
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 main():
N, M = list(map(int, readline().split()))
P = [int(s) - 1 for s in readline().split()]
XY = list(map(int, read().split()))
uf = UnionFind(N)
for x, y in zip(*[iter(XY)] * 2):
uf.union(x - 1, y - 1)
Q = [0] * N
for i, p in enumerate(P):
Q[p] = i
ans = 0
for i, p in enumerate(P):
if i == p or uf.same(i, Q[i]):
ans += 1
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class UnionFind:
# Reference: https://note.nkmk.me/python-union-find/
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 main():
N, M = list(map(int, readline().split()))
P = [int(s) - 1 for s in readline().split()]
XY = list(map(int, read().split()))
uf = UnionFind(N)
for x, y in zip(*[iter(XY)] * 2):
uf.union(x - 1, y - 1)
ans = 0
for i, p in enumerate(P):
if i == p or uf.same(i, p):
ans += 1
print(ans)
return
if __name__ == '__main__':
main()
| p03354 |
tmp = list(map(int,input().split()))
n,p,q = tmp[0],tmp[1],tmp[2]
cs = []
for i in range(n):
cs.append(int(eval(input())))
ans = [sum(cs)]
difs = [p * (q-i) - cs[i] for i in range(n)]
difs.sort(reverse = True)
for i in range(n):
ans.append(ans[-1] + 2 * i * p + difs[i])
print((max(ans)))
| #着席位置は中央*奥
#問題は「Dinner」(http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2642&lang=jp)
#方針としては、自炊をする回数(0~n)を決め打ちし、それぞれの時の最大値を計算してその最大値を返すことにする
#n回自炊するとき、自炊パワーはn-1回自壊する時に比べ最終的に2増える。
#これを考えると、n回自炊する時、高まる自炊パワーによる幸福度の増加分はn*(n+1)となる
#したがって、まずリストdifsに「自炊と食堂の幸福度の差分」を全て入れる
#これを降順にソートし、n回自炊した時の幸福度の最大値をansに入れていく
#ansの最大値を出力して、終了
n,p,q = list(map(int,input().split()))
cs = []
for i in range(n):
cs.append(int(eval(input())))
ans = [sum(cs)]
difs = [p * (q-i) - cs[i] for i in range(n)]
difs.sort(reverse = True)
for i in range(n):
ans.append(ans[-1] + 2 * i * p + difs[i])
print((max(ans)))
| p01754 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
a,b,c,d = MI()
print((max(a*c,a*d,b*c,b*d)))
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
a,b,c,d = MI()
print((max(a*c,a*d,b*c,b*d)))
| p02553 |
a,b,c,d=list(map(int,input().split()))
ans=0
if a>=0:
if c>=0:
ans=b*d
elif d>=0:
ans=b*d
else:
ans=a*d
elif b>=0:
if c>=0:
ans=b*d
elif d>=0:
ans=max(b*d,a*c)
else:
ans=a*c
else:
if c>=0:
ans=b*c
elif d>=0:
ans=a*c
else:
ans=a*c
print(ans) | a,b,c,d=list(map(int,input().split()))
ans=max(a*c,a*d,b*c,b*d)
print(ans) | p02553 |
def LI():return list(map(int,input().split()))
def II():return int(input())
def yes():return print("Yes")
def no():return print("No")
INF=float("inf")
from collections import deque, defaultdict, Counter
from heapq import heappop, heappush
from itertools import product, combinations
from functools import reduce, lru_cache
from math import pi, gcd
from decimal import Decimal
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
class Unionfind:
def __init__(self, N):
self.p = list(range(N))
self.rank = [0] * N
self.size = [1] * N
def root(self, x):
if self.p[x] != x:
self.p[x] = self.root(self.p[x])
return self.p[x]
def same(self, x, y):
return self.root(x) == self.root(y)
def unite(self, x, y):
u = self.root(x)
v = self.root(y)
if u == v: return
if self.rank[u] < self.rank[v]:
self.p[u] = v
self.size[v] += self.size[u]
self.size[u] = 0
else:
self.p[v] = u
self.size[u] += self.size[v]
self.size[v] = 0
if self.rank[u] == self.rank[v]:
self.rank[u] += 1
def count(self, x):
return self.size[self.root(x)]
a,b,c,d=LI()
print(max(a*c,b*c,a*d,b*d))
| a,b,c,d=list(map(int,input().split()))
print((max(a*c,a*d,b*c,b*d))) | p02553 |
#!/usr/bin/env python3
import sys
input=sys.stdin.readline
a,b,c,d=list(map(int,input().split()))
ans=-10**18
#x=0 or y=0
if a<=0<=b or c<=0<=d:
ans=max(ans,0)
#x<0 and y>0
ans=max(ans,b*c)
#x>0 and y>0
ans=max(ans,b*d)
#x<0 and y<0
ans=max(ans,a*c)
#x>0 and y<0
ans=max(ans,a*d)
print(ans) | ans=-10**18
a,b,c,d=list(map(int,input().split()))
if a<=0<=b or c<=0<=d:
ans=0
ans=max(ans,a*c,a*d,b*c,b*d)
print(ans) | p02553 |
a=list(map(int,input().split()))
b=a[0]*a[2]
c=a[0]*a[3]
d=a[1]*a[2]
e=a[1]*a[3]
print((max(b,c,d,e))) | t=list(map(int,input().split()))
print((max(t[0]*t[2],t[0]*t[3],t[1]*t[2],t[1]*t[3]))) | p02553 |
a,b,c,d = list(map(int,input().split()))
print((max([a*c,a*d,b*c,b*d])))
| a,b,c,d = list(map(int,input().split()))
ans=[]
for X in [a,b]:
for Y in [c,d]:
ans.append(X*Y)
print((max(ans)))
| p02553 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
a, b, c, d = list(map(int, readline().split()))
ans = -INF
for x in (a, b):
for y in (c, d):
ans = max(ans, x * y)
print(ans)
if __name__ == '__main__':
main()
| a, b, c, d = list(map(int, input().split()))
ans = -float("INF") # 答えがマイナスになることがあるので、負の無限大を初期値にしておきます
for x in (a, b):
for y in (c, d):
ans = max(ans, x * y)
print(ans) | p02553 |
a,b,c,d=list(map(int,input().split()))
print((max(max(max(a*c,a*d),b*c),b*d))) | a,b,c,d=list(map(int,input().split()))
l=[a*c,a*d,b*c,b*d]
print((max(l))) | p02553 |
def l_in(type_): return list(map(type_, input().split()))
def i_in(): return int(eval(input()))
def m_in(type_): return list(map(type_, input().split()))
def r_in(n, type_): return [type_(eval(input())) for _ in range(n)]
ans = None
def absmax(a, b):
if abs(a) > abs(b): return a
return b
def absmin(a, b):
if abs(a) < abs(b): return a
return b
a, b, c, d = m_in(int)
aa, bb, cc, dd = abs(a), abs(b), abs(c), abs(d)
x, y = 0, 0
abm = absmax(a, b)
cdm = absmax(c, d)
if (abm>0) == (cdm>0):
ans = abm*cdm
else:
abi = absmin(a, b)
cdi = absmin(c, d)
if (abi>0) == (cdm>0):
k = abi*cdm
if ans is None or k > ans: ans = k
if (abm>0) == (cdi>0):
k = abm*cdi
if ans is None or k > ans: ans = k
k = abi*cdi
if ans is None: ans = k
print(ans)
| def l_in(type_): return list(map(type_, input().split()))
def i_in(): return int(eval(input()))
def m_in(type_): return list(map(type_, input().split()))
def r_in(n, type_): return [type_(eval(input())) for _ in range(n)]
ans = None
a, b, c, d = m_in(int)
ans = max(a*c, a*d, b*c, b*d)
print(ans)
| p02553 |
from sys import stdin
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
a, b, c, d = list(map(int, _in[0].split(' '))) # type:list(int)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
cnt = -float('inf')
cnt = max(cnt, a * c)
cnt = max(cnt, a * d)
cnt = max(cnt, b * c)
cnt = max(cnt, b * d)
ans = cnt
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
main()
| from sys import stdin
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
a, b, c, d = list(map(int, _in[0].split(' '))) # type:list(int)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
ans = -float('inf')
for _ in [a * c, a * d, b * c, b * d]:
ans = max(ans, _)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
main()
| p02553 |
a, b, c, d = list(map(int, input().split()))
answer = 0
if a < 0 and 0 <= b:
if c < 0 and 0 <= d:
answer = max(a * c, b * d)
elif 0 <= c and 0 <= d:
answer = b * d
elif c < 0 and d < 0:
answer = a * c
elif 0 <= a and 0 <= b:
if c < 0 and 0 <= d:
answer = b * d
elif 0 <= c and 0 <= d:
answer = b * d
elif c < 0 and d < 0:
answer = a * d
elif a < 0 and b < 0:
if c < 0 and 0 <= d:
answer = a * c
elif 0 <= c and 0 <= d:
answer = b * c
elif c < 0 and d < 0:
answer = a * c
print(answer) | a, b, c, d = list(map(int, input().split()))
answer = max(a*c, a*d, b*c, b*d)
print(answer) | p02553 |
a,b,c,d = list(map(int, input().split()))
ans = b*d
ans = max(ans, a*c)
ans = max(ans, b*d)
ans = max(ans, a*d)
ans = max(ans, b*c)
print(ans)
| a, b, c, d = list(map(int, input().split()))
print((max(a*c, a*d, b*c, b*d)))
| p02553 |
a,b,c,d=list(map(int,input().split()))
X=[a,b]
Y=[c,d]
ans=-10**30
for x in X:
for y in Y:
if ans<x*y:
ans=x*y
print(ans)
| a,b,c,d=list(map(int,input().split()))
print((max(a*c,a*d,b*c,b*d)))
| p02553 |
a, b, c, d = list(map(int, input().split()))
if a > 0 and b > 0 and c > 0 and d > 0:
print((max(a,b)*max(c,d)))
elif a == 0 or b == 0 or c == 0 or d == 0:
print((max([a*c, a*d, b*c, b*d])))
else:
res = []
for i in range(a, b+1):
for j in range(c, d+1):
res.append(i*j)
print((max(res))) | a, b, c, d = list(map(int, input().split()))
print((max([a*c, b*c, a*d, b*d]))) | p02553 |
(X1,X2,Y1,Y2)=list(map(int,input().split()))
ans=X2*Y2
ans=max(ans,X1*Y1)
ans=max(ans,X1*Y2)
ans=max(ans,X2*Y1)
print (ans) | (X1,X2,Y1,Y2)=list(map(int,input().split()))
ans=max(X2*Y2,X1*Y1,X1*Y2,X2*Y1)
print (ans) | p02553 |
a, b, c, d = list(map(int, input().split()))
cnt = []
if a == c and b == d:
print((max(a*c, b*d)))
exit()
else:
for i in range(a, b+1):
for j in range(c, d+1):
cnt.append(i*j)
C = sorted(cnt)
print((max(C[0],C[-1])))
| a, b, c, d = list(map(int,input().split()))
if a == c and b == d:
print((max(a*c, b*d)))
exit()
else:
print((max(a*c, a*d,b*c,b*d))) | p02553 |
a,b,c,d=list(map(int,input().split()))
if a>=0:
if c>=0:
print((b*d))
elif c<0 and d>=0:
print((b*d))
elif d<0:
print((a*d))
elif a<0 and b>=0:
if c>=0:
print((b*d))
elif c<0 and d>=0:
print((max(a*c,b*d)))
elif d<0:
print((a*c))
elif b<0:
if c>=0:
print((b*c))
elif c<0 and d>=0:
print((a*c))
elif d<0:
print((a*c))
| a,b,c,d=list(map(int,input().split()))
maxxy=max(a*c,a*d,b*c,b*d)
print(maxxy) | p02553 |
a, b, c, d = list(map(int, input().split()))
minx = min(a, b)
miny = min(c, d)
maxx = max(a, b)
maxy = max(c, d)
print((max(miny * minx, maxx * maxy, maxx * miny, minx * maxy)))
| a, b, c, d = list(map(int, input().split()))
print((max(a * c, b * d, b * c, a * d))) | p02553 |
import itertools
a,b,c,d=list(map(int,input().split()))
ans=-10**9
if b<=0 and d<=0:
ans=a*c
else :
x=list(int(x) for x in range(a,b+1))
y=list(int(y) for y in range(c,d+1))
l=list(itertools.product(x, y))
for i in range(len(l)):
if ans<l[i][0]*l[i][1]:
ans=l[i][0]*l[i][1]
print(ans) | a,b,c,d=list(map(int,input().split()))
ans=max(a*c,a*d,b*c,b*d)
print(ans) | p02553 |
def main():
a, b, c, d = list(map(int, input().split()))
if (a <= 0 and b >= 0) or (c <=0 and d >= 0):
print((max(a*c, b*d, 0)))
else:
print((max(a*c, b*d, a*d, b*c)))
if __name__ == "__main__":
main() | def main():
a, b, c, d = list(map(int, input().split()))
if a*b > 0 and c*d > 0 and a*c < 0:
print((max(a*d, b*c)))
else:
print((max(a*c, b*d, 0)))
if __name__ == "__main__":
main() | p02553 |
a,b,c,d = list(map(int, input().split()))
t = list()
ac = a*c
bc = b*c
ad = a*d
bd = b*d
t.append(ac)
t.append(bc)
t.append(ad)
t.append(bd)
ans = -1 * 10**18
for i in range(4):
ans = max(t[i],ans)
print(ans) | a,b,c,d = list(map(int, input().split()))
ans = max(a*c, a*d, b*c, b*d)
print(ans) | p02553 |
from collections import Counter
import copy
N = int(eval(input()))
D = list(map(int, input().split()))
if N == 1:
print((min(D[0], 24-D[0])))
exit()
D.append(0)
D.append(24)
c = Counter(D)
times = []
p = []
for num, cnt in list(c.items()):
if (num == 0 or num == 12) and cnt >= 2:
# D==24-D になるかつ時差０の組がいるので時差の最小は０で確定
print((0))
exit()
elif cnt >= 3:
# 時差０の組み合わせがある
print((0))
exit()
elif cnt == 2:
# Dと24-Dに一人ずつ
times.append(num)
times.append(24-num)
elif cnt == 1:
# D or 24-D のどちらか一方に一人だけいる状態なので別枠で確保
p.append((num, 24-num))
num_b = len(p)
ans = 0
# D or 24-Dの可能性があるものについて全パターン試すために、2進表記を利用
for b in range(2**num_b):
b = bin(b)[2:].zfill(num_b)
time = copy.deepcopy(times)
for i in range(num_b):
if b[i] == "0":
time.append(p[i][0])
else:
time.append(p[i][1])
tmp = 24
for i in range(len(time)):
for j in range(i+1, len(time)):
tmp = min(tmp, abs(time[i] - time[j]))
ans = max(ans, tmp)
print(ans) | from collections import Counter
import copy
N = int(eval(input()))
D = list(map(int, input().split()))
if N == 1:
print((min(D[0], 24-D[0])))
exit()
D.append(0)
D.append(24) # 24-0のパターン
c = Counter(D)
times = []
p = []
for num, cnt in list(c.items()):
if (num == 0 or num == 12) and cnt >= 2:
# D==24-D になるかつ時差０の組がいるので時差の最小は０で確定
print((0))
exit()
elif cnt >= 3:
# 時差０の組み合わせがある
print((0))
exit()
elif cnt == 2:
# Dと24-Dに一人ずつ
times.append(num)
times.append(24-num)
elif cnt == 1:
# D or 24-D のどちらか一方に一人だけいる状態なので別枠で確保
p.append((num, 24-num))
num_b = len(p)
ans = 0
# D or 24-Dの可能性があるものについて全パターン試すために、2進表記を利用
for b in range(2**num_b):
b = bin(b)[2:].zfill(num_b)
time = copy.deepcopy(times)
for i in range(num_b):
if b[i] == "0":
time.append(p[i][0])
else:
time.append(p[i][1])
tmp = 24
for i in range(len(time)):
for j in range(i+1, len(time)):
tmp = min(tmp, abs(time[i] - time[j]))
ans = max(ans, tmp)
print(ans) | p03525 |
from collections import Counter
import copy
N = int(eval(input()))
D = list(map(int, input().split()))
if N == 1:
print((min(D[0], 24-D[0])))
exit()
D.append(0)
D.append(24) # 24-0のパターン
c = Counter(D)
times = []
p = []
for num, cnt in list(c.items()):
if (num == 0 or num == 12) and cnt >= 2:
# D==24-D になるかつ時差０の組がいるので時差の最小は０で確定
print((0))
exit()
elif cnt >= 3:
# 時差０の組み合わせがある
print((0))
exit()
elif cnt == 2:
# Dと24-Dに一人ずつ
times.append(num)
times.append(24-num)
elif cnt == 1:
# D or 24-D のどちらか一方に一人だけいる状態なので別枠で確保
p.append((num, 24-num))
num_b = len(p)
ans = 0
# D or 24-Dの可能性があるものについて全パターン試すために、2進表記を利用
for b in range(2**num_b):
b = bin(b)[2:].zfill(num_b)
time = copy.deepcopy(times)
for i in range(num_b):
if b[i] == "0":
time.append(p[i][0])
else:
time.append(p[i][1])
tmp = 24
for i in range(len(time)):
for j in range(i+1, len(time)):
tmp = min(tmp, abs(time[i] - time[j]))
ans = max(ans, tmp)
print(ans) |
from collections import Counter
from collections import defaultdict
N = list(map(int, input().split()))
D = list(map(int, input().split()))
c = Counter(D)
# 高橋君と同じ時間帯の人が一人でもいれば、時差の最小は常に0
if c[0] >= 2:
print((0))
exit(0)
# 高橋君との時差がdの人が3人以上いる場合も、時差の最小は常に0（同じ時間帯の都市に二人以上いることになるから）
for i in list(c.values()):
if i >= 3:
print((0))
exit()
times = defaultdict(int)
c[0] += 1
# 0時との時間差をとるときに24がいたほうがよいか？なくてもいいか。
c[24] += 1
before_12 = True
D.sort()
for d in D:
if before_12:
times[d] += 1
before_12 = False
else:
times[24-d] += 1
before_12 = True
# 高橋君との時差で答えを初期化
ans = min(D)
tlst = list(times.keys())
tlst.sort()
for a,b in zip(tlst, tlst[1:]):
ans = min(ans, b - a)
print(ans)
| p03525 |
from collections import Counter
from collections import defaultdict
N = list(map(int, input().split()))
D = list(map(int, input().split()))
c = Counter(D)
# 高橋君と同じ時間帯の人が一人でもいれば、時差の最小は常に0
if c[0] >= 2:
print((0))
exit(0)
# 高橋君との時差がdの人が3人以上いる場合も、時差の最小は常に0（同じ時間帯の都市に二人以上いることになるから）
for i in list(c.values()):
if i >= 3:
print((0))
exit()
times = defaultdict(int)
c[0] += 1
# 0時との時間差をとるときに24がいたほうがよいか？なくてもいいか。
c[24] += 1
before_12 = True
D.sort()
for d in D:
if before_12:
times[d] += 1
before_12 = False
else:
times[24-d] += 1
before_12 = True
# 高橋君との時差で答えを初期化
ans = min(D)
tlst = list(times.keys())
tlst.sort()
for a,b in zip(tlst, tlst[1:]):
ans = min(ans, b - a)
print(ans)
|
from collections import Counter
from collections import defaultdict
N = list(map(int, input().split()))
D = list(map(int, input().split()))
c = Counter(D)
c[0] += 1
# 高橋君と同じ時間帯の人が一人でもいれば、時差の最小は常に0
if c[0] >= 2:
print((0))
exit(0)
# 高橋君との時差がdの人が3人以上いる場合も、時差の最小は常に0（同じ時間帯の都市に二人以上いることになるから）
for i in list(c.values()):
if i >= 3:
print((0))
exit()
times = defaultdict(int)
# 0時との時間差をとるときに24がいたほうがよいか？なくてもいいか。
c[24] += 1
before_12 = True
D.sort()
for d in D:
if before_12:
times[d] += 1
before_12 = False
else:
times[24-d] += 1
before_12 = True
# 高橋君との時差で答えを初期化
ans = min(D)
tlst = list(times.keys())
tlst.sort()
for a,b in zip(tlst, tlst[1:]):
ans = min(ans, b - a)
print(ans)
| p03525 |
N = int(eval(input()))
D = list(map(int, input().split()))
if N >= 24:
print((0))
else:
res = 0
for bit in range(2**N):
d = [0 for _ in range(24)]
for i in range(N):
if (bit >> i) & 1:
d[D[i]] += 1
else:
d[(24 - D[i]) % 24] += 1
md = 25
tmp = 0
for i in range(24):
if d[i] > 1:
md = 0
break
elif d[i] == 1:
md = min(md, i - tmp)
tmp = i
md = min(24 - tmp, md)
res = max(res, md)
print(res) | N = int(eval(input()))
D = list(map(int, input().split()))
if N >= 24:
print((0))
elif N == 23:
d = [0 for _ in range(13)]
d[0] = 1
for i in range(N):
d[D[i]] += 1
if d[0] > 1 or d[12] > 1:
print((0))
else:
for i in range(1, 12):
if d[i] > 2:
print((0))
break
else:
print((1))
else:
res = 0
for bit in range(2**N):
d = [0 for _ in range(24)]
d[0] = 1
for i in range(N):
if (bit >> i) & 1:
d[D[i]] += 1
else:
d[(24 - D[i]) % 24] += 1
s = 25
tmp = 0
if d[0] > 1:
s = 0
else:
for i in range(1, 24):
if d[i] > 1:
s = 0
break
elif d[i] == 1:
s = min(s, i - tmp)
tmp = i
s = min(s, (24 - tmp) % 24)
res = max(res, s)
print(res) | p03525 |
from collections import Counter
from itertools import product
def solve(LIST):
stmp = [i for i, li in enumerate(LIST * 2) if li == 1]
S = min(stmp[i] - stmp[i - 1] for i in range(1, len(stmp)))
return S
n = int(eval(input()))
d = Counter(list(map(int, input().split())) + [0])
if any(d[num] > (2 - (num in {0, 12})) for num in d):
print((0))
exit()
ans, cnt = [0] * 24, []
for num in d:
if (num in {0, 12}) and d[num] == 1:
ans[num] = 1
elif d[num] == 2:
ans[num], ans[24 - num] = 1, 1
elif d[num] == 1:
cnt.append(num)
s = 0
if len(cnt) == 0:
s = max(s, solve(ans))
for bit in product([1, -1], repeat=len(cnt)):
tmp = ans[:]
for bi, ci in zip(bit, cnt):
tmp[(ci - 12) * bi + 12] = 1
s = max(s, solve(tmp))
print(s)
| n = int(eval(input()))
d = sorted(list(map(int, input().split())) + [0])
bit, cnt = [0] * 24, 1
for num in d:
bit[((num - 12) * cnt + 12) % 24] += 1
cnt *= -1
if any(i > 1 for i in bit):
print((0))
exit()
ans = [i for i, li in enumerate(bit * 2) if li == 1]
s = min(ans[i] - ans[i - 1] for i in range(1, len(ans)))
print(s)
| p03525 |
n = int(eval(input()))
d = sorted(list(map(int, input().split())) + [0])
bit, cnt = [0] * 24, 1
for num in d:
bit[((num - 12) * cnt + 12) % 24] += 1
cnt *= -1
if any(i > 1 for i in bit):
print((0))
exit()
ans = [i for i, li in enumerate(bit * 2) if li == 1]
s = min(ans[i] - ans[i - 1] for i in range(1, len(ans)))
print(s)
| n = int(eval(input()))
d = sorted(list(map(int, input().split())) + [0])
ans, cnt = [], 1
for num in d:
ans.append(((num - 12) * cnt + 12) % 24)
cnt *= -1
ans = sorted(ans + [i + 24 for i in ans])
s = min(ans[i] - ans[i - 1] for i in range(1, len(ans)))
print(s)
| p03525 |
n=int(eval(input()))
d=list(map(int,input().split()))
if n>=24:
print((0))
exit()
if n==23:
print((1))
op=2**n-1
ans=0
for i in range(op):
t=[0]
for j in range(n):
if i&(2**j)>0:
t.append(d[j])
else:
t.append(24-d[j])
a=10000
for p in range(1,1+n):
for q in range(p):
b=abs(t[p]-t[q])
a=min(a,min(b,24-b))
ans=max(ans,a)
print(ans)
| n=int(eval(input()))
d=list(map(int,input().split()))
if n>=24:
print((0))
exit()
if n>=22:
t=[]
d.append(0)
d.sort()
f=1
for i in range(n):
if d[i]==d[i+1]:
f+=1
else:
if f>2:
print((0))
exit()
f=1
print((1))
exit()
op=2**n-1
ans=0
for i in range(op):
t=[0]
for j in range(n):
if i&(2**j)>0:
t.append(d[j])
else:
t.append(24-d[j])
a=10000
for p in range(1,1+n):
for q in range(p):
b=abs(t[p]-t[q])
a=min(a,min(b,24-b))
ans=max(ans,a)
print(ans)
| p03525 |
import math
from typing import List, Counter, Tuple
from collections import Counter
from itertools import permutations
def read_int() -> int:
return int(input().strip())
def read_ints() -> List[int]:
return list(map(int, input().strip().split(' ')))
INF = 10**9
def solve() -> int:
N = read_int()
D = read_ints()
if N>23:
return 0
max_distance = -INF
for mask in range(1<<N):
distances = [0]
min_distance = INF
temp = mask
for i in range(N):
if temp&1 == 0:
d = D[i]
else:
d = 24-D[i]
current = min(min(abs(d0-d), 24-abs(d0-d)) for d0 in distances)
distances.append(d)
if current < min_distance:
min_distance = current
temp >>= 1
if min_distance > max_distance:
max_distance = min_distance
return max_distance
if __name__ == '__main__':
print((solve()))
| import math
from typing import List, Counter, Tuple
from collections import Counter
from itertools import permutations
def read_int() -> int:
return int(input().strip())
def read_ints() -> List[int]:
return list(map(int, input().strip().split(' ')))
INF = 10**9
def solve() -> int:
N = read_int()
D = read_ints()
if N>23:
return 0
D.sort(key=lambda d:min(d, 24-d))
right = True
assignment = [False]*24
assignment[0] = True
for d in D:
if right:
if assignment[d]:
return 0
assignment[d] = True
else:
if assignment[(24-d)%24]:
return 0
assignment[(24-d)%24] = True
right = not right
count = 0
counts = []
for i in range(1, len(assignment)+1):
i %= 24
if not assignment[i]:
count += 1
else:
counts.append(count)
count = 0
return min(counts)+1
if __name__ == '__main__':
print((solve()))
| p03525 |
def main():
N = int(input())
D = [int(i) for i in input().split()]
ans = 0
cnt = [0]*24
from collections import Counter
c = Counter(D)
cnt[0] = 1
s = [0]*13
for k, v in c.items():
if v >= 3 or k == 0:
ans = 0
return print(ans)
elif v >= 2:
cnt[k] += 1
cnt[24 - k] += 1
elif k == 12:
cnt[12] += v
else:
s[k] += 1
if any(c >= 2 for c in cnt):
return print(0)
for bit in range(1 << 11):
cur = cnt[:]
for i in range(11):
if s[i+1]:
if bit & (1 << i):
cur[24 - (i+1)] += 1
else:
cur[i+1] += 1
if any(c >= 2 for c in cnt):
continue
pre = 0
mi = 24
for i, ne in enumerate(cur[1:] + [1], start=1):
if ne:
if i - pre < mi:
mi = i - pre
pre = i
if mi != 24:
ans = max(ans, mi)
print(ans)
if __name__ == '__main__':
main()
| def main():
_ = int(input())
D = [int(i) for i in input().split()]
ans = 0
cnt = [0]*24
from collections import Counter
c = Counter(D)
cnt[0] = 1
s = [0]*13
for k, v in c.items():
if v >= 3:
ans = 0
return print(ans)
elif k == 0 or k == 12:
cnt[k] += v
elif v >= 2:
cnt[k] += 1
cnt[24 - k] += 1
else:
s[k] += 1
if any(c >= 2 for c in cnt):
return print(0)
for bit in range(1 << 11):
cur = cnt[:]
for i in range(11):
if s[i+1]:
if bit & (1 << i):
cur[24 - (i+1)] += 1
else:
cur[i+1] += 1
pre = 0
mi = 24
for i, ne in enumerate(cur[1:] + [1], start=1):
if ne:
if i - pre < mi:
mi = i - pre
pre = i
ans = max(ans, mi)
print(ans)
if __name__ == '__main__':
main()
| p03525 |
import math
#import sys
#input = sys.stdin.readline
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
def ValueToBits(x,digit):
res = [0 for i in range(digit)]
now = x
for i in range(digit):
res[i]=now%2
now = now >> 1
return res
def BitsToValue(arr):
n = len(arr)
ans = 0
for i in range(n):
ans+= arr[i] * 2**i
return ans
def ZipArray(a):
aa = [[a[i],i]for i in range(n)]
aa.sort(key = lambda x : x[0])
for i in range(n):
aa[i][0]=i+1
aa.sort(key = lambda x : x[1])
b=[aa[i][0] for i in range(len(a))]
return b
def ValueToArray10(x, digit):
ans = [0 for i in range(digit)]
now = x
for i in range(digit):
ans[digit-i-1] = now%10
now = now //10
return ans
def Zeros(a,b):
if(b<=-1):
return [0 for i in range(a)]
else:
return [[0 for i in range(b)] for i in range(a)]
def AddV2(v,w):
return [v[0]+w[0],v[1]+w[1]]
dir4 = [[1,0],[0,1],[-1,0],[0,-1]]
def clamp(x,y,z):
return max(y,min(z,x))
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
#
def Zaatsu(a):
a.sort()
now = a[0][0]
od = 0
for i in range(n):
if(now==a[i][0]):
a[i][0]=od
else:
now = a[i][0]
od+=1
a[i][0] = od
a.sort(key = lambda x : x[1])
return a
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (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 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 same_check(self, x, y):
return self.find(x) == self.find(y)
'''
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 2
N = 10 ** 6 + 2
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
'''
def rl(x):
return list(range(len(x)))
# a = list(map(int, input().split()))
#################################################
#################################################
#################################################
#################################################
#11-
n = int(eval(input()))
aa = list(map(int, input().split()))
t = [0 for i in range(13)]
a=[]
for i in aa:
if(i==0):
print((0))
exit()
if(t[i]<=1):
t[i]+=1
a.append(i)
elif(t[i]==2):
print((0))
exit()
#print(a)
n = len(a)
b = [0 for i in range(25)]
ans = 0
count = 0
for i in range(2**(n-1)):
count +=1
for j in range(25):
b[j]=0
b[0]=1
b[24]=1
for j in range(n):
if((i>>j) & 1):
b[24-a[j]] += 1
else:
b[a[j]] += 1
minim = 24
prev = -24
for j in range(0,25):
if(b[j]==1):
minim = min(minim, j-prev)
prev = j
elif(b[j]>=2):
minim = 0
break
ans = max(ans,minim)
#print(b)
print(ans)
#print(count)
| import math
#import sys
#input = sys.stdin.readline
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
def ValueToBits(x,digit):
res = [0 for i in range(digit)]
now = x
for i in range(digit):
res[i]=now%2
now = now >> 1
return res
def BitsToValue(arr):
n = len(arr)
ans = 0
for i in range(n):
ans+= arr[i] * 2**i
return ans
def ZipArray(a):
aa = [[a[i],i]for i in range(n)]
aa.sort(key = lambda x : x[0])
for i in range(n):
aa[i][0]=i+1
aa.sort(key = lambda x : x[1])
b=[aa[i][0] for i in range(len(a))]
return b
def ValueToArray10(x, digit):
ans = [0 for i in range(digit)]
now = x
for i in range(digit):
ans[digit-i-1] = now%10
now = now //10
return ans
def Zeros(a,b):
if(b<=-1):
return [0 for i in range(a)]
else:
return [[0 for i in range(b)] for i in range(a)]
def AddV2(v,w):
return [v[0]+w[0],v[1]+w[1]]
dir4 = [[1,0],[0,1],[-1,0],[0,-1]]
def clamp(x,y,z):
return max(y,min(z,x))
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
#
def Zaatsu(a):
a.sort()
now = a[0][0]
od = 0
for i in range(n):
if(now==a[i][0]):
a[i][0]=od
else:
now = a[i][0]
od+=1
a[i][0] = od
a.sort(key = lambda x : x[1])
return a
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (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 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 same_check(self, x, y):
return self.find(x) == self.find(y)
'''
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 2
N = 10 ** 6 + 2
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
'''
def rl(x):
return list(range(len(x)))
# a = list(map(int, input().split()))
#################################################
#################################################
#################################################
#################################################
#11-
n = int(eval(input()))
aa = list(map(int, input().split()))
t = [0 for i in range(13)]
a=[]
for i in aa:
if(i==0):
print((0))
exit()
if(t[i]<=1):
t[i]+=1
a.append(i)
elif(t[i]==2):
print((0))
exit()
#print(a)
n = len(a)
if(t[1]>=1):
print((1))
exit()
b = [0 for i in range(25)]
ans = 0
count = 0
for i in range(2**(n-1)):
count +=1
for j in range(25):
b[j]=0
b[0]=1
b[24]=1
for j in range(n):
if((i>>j) & 1):
b[24-a[j]] += 1
else:
b[a[j]] += 1
minim = 24
prev = -24
for j in range(0,25):
if(b[j]==1):
minim = min(minim, j-prev)
prev = j
elif(b[j]>=2):
minim = 0
break
ans = max(ans,minim)
#print(b)
print(ans)
#print(count)
| p03525 |
from itertools import product
import random
def solve(n,dl):
# n = int(input())
# dl = list(map(int, input().split()))
if 0 in dl:
return 0
doubles = []
dl1 = []
dl2 = []
for i in range(1,13):
i_cnt = dl.count(i)
if i_cnt > 2:
return 0
elif i_cnt == 2:
dl2.append(24-i)
dl2.append(i)
elif i_cnt == 1:
dl1.append(i)
ans = 0
ite = list(product(list(range(2)),repeat=len(dl1)))
for pattern in ite:
dl24 = [0,24]
for i, v in enumerate(pattern):
if v == 1:
dl24.append(24-dl1[i])
else:
dl24.append(dl1[i])
dl24 = dl24 + dl2
dl24.sort()
diff_min = 24
# print(dl24)
if len(dl24) == 1:
ans = max(ans, min(dl24[0], 24-dl24[0]))
else:
for a,b in zip(dl24[:-1],dl24[1:]):
diff = b-a
if diff != 24:
diff_min = min(diff_min,diff)
ans = max(diff_min,ans)
return ans
def solve2(n,dl):
ite = list(product(list(range(2)),repeat=len(dl)))
ans = 0
for pattern in ite:
dl_new = [0]
for i, v in enumerate(pattern):
if v == 1:
dl_new.append(24-dl[i])
else:
dl_new.append(dl[i])
dl_new.sort()
diff_min = 24
for a,b in zip(dl_new[:-1], dl_new[1:]):
diff = b-a
diff_min = min(diff_min, diff)
ans = max(ans,diff_min)
return ans
if __name__ == "__main__":
n = int(eval(input()))
dl = list(map(int, input().split()))
ans = solve(n,dl)
print(ans)
# for _ in range(10):
# n = random.randint(1,10)
# dl = [random.randint(1,12) for _ in range(n)]
# ans1 = solve(n, dl[:])
# ans2 = solve2(n,dl[:])
# if ans1 != ans2:
# print(n)
# print(dl)
# print(ans1)
# print(ans2)
# print('----') | n = int(eval(input()))
dl = list(map(int, input().split()))
if 0 in dl:
print((0))
exit()
dl.sort()
dl1 = [0,24]
dl2 = [0,24]
for i, d in enumerate(dl):
if i%2 == 0:
dl1.append(d)
dl2.append(24-d)
else:
dl1.append(24-d)
dl2.append(d)
dl1.sort()
dl2.sort()
min_1 = 24
for a,b in zip(dl1[1:],dl1[:-1]):
diff = a-b
min_1 = min(min_1,diff)
min_2 = 24
for a,b in zip(dl2[1:],dl2[:-1]):
diff = a-b
min_2 = min(min_2,diff)
ans = max(min_1,min_2)
print(ans)
| p03525 |
N = int(eval(input()))
D = [int(d) for d in input().split()]
D.append(0)
D.sort()
ans = 0
time1 = []
time2 = []
for i in range(N+1):
if D.count(D[i]) == 2:
if D[i] == 0:
ans = -1
break
time2.append(D[i])
time2.append(24-D[i])
if D.count(D[i]) + D.count(24-D[i]) > 2:
ans = -1
break
if D.count(D[i]) == 1:
time1.append(D[i])
time2 = set(time2)
if ans == 0:
for i in range(2**len(time1)):
temp = []
for j in range(len(time1)):
if i & 1<<j:
temp.append(24-time1[j])
else:
temp.append(time1[j])
temp += list(time2)
temp.sort()
cnt = 24-temp[-1]
if temp[-1] == 0:
cnt = 0
for k in range(len(temp)-1):
cnt = min(cnt, temp[k+1]-temp[k])
ans = max(ans, cnt)
else:
ans = 0
print(ans) | N = int(eval(input()))
D = [int(d) for d in input().split()]
D.append(0)
D.sort()
for i in range(1, N+1):
if i%2 == 0:
D[i] = 24-D[i]
D.sort()
ans = min(D[-1], 24-D[-1])
for i in range(N):
ans = min(ans, D[i+1]-D[i])
print(ans) | p03525 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
return [[]]*num
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(II()) for _ in range(N)]
return list(map(list, list(zip(*read_all))))
#################
from itertools import product
N = I()
D = III()
if N>=24:
print((0))
elif 0 in D:
print((0))
else:
a = list(product([0,1],repeat=N))
ans = 0
for a0 in a:
l = [False]*24
flag = False
for i in range(N):
if a0[i]==0:
if l[D[i]]:
flag = True
break
else:
l[D[i]] = True
else:
if l[24-D[i]]:
flag = True
break
else:
l[24-D[i]] = True
if flag:
continue
before = 0
val = 13
for i in range(24):
if l[i]:
temp = min(i-before, 24-i+before)
before = i
if temp<val:
val = temp
temp = min(before,24-before)
if temp<val:
val = temp
if val>ans:
ans = val
print(ans) | import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
return [[]]*num
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(II()) for _ in range(N)]
return list(map(list, list(zip(*read_all))))
#################
from itertools import product
N = I()
D = III()
if 0 in D:
print((0))
elif N>=24:
print((0))
elif N==23:
D.sort()
for i in range(N):
if D[i]!=i//2+1:
print((0))
exit()
print((1))
else:
a = list(product([0,1],repeat=N))
ans = 0
for a0 in a:
l = [False]*24
flag = False
for i in range(N):
if a0[i]==0:
if l[D[i]]:
flag = True
break
else:
l[D[i]] = True
else:
if l[24-D[i]]:
flag = True
break
else:
l[24-D[i]] = True
if flag:
continue
before = 0
val = 13
for i in range(24):
if l[i]:
temp = min(i-before, 24-i+before)
before = i
if temp<val:
val = temp
temp = min(before,24-before)
if temp<val:
val = temp
if val>ans:
ans = val
print(ans) | p03525 |
from collections import Counter
import itertools
N = int(eval(input()))
D = list(map(int, input().split()))
M = Counter(D)
if max(M.values()) > 2:
print((0))
elif 0 in D:
print((0))
else:
D = [[x, 24-x] for x in D]
generator = list(itertools.product([0, 1], repeat=N))
D_gen = [[D[i][g[i]] for i in range(N)] for g in generator]
ans = 0
for d in D_gen:
if len(set(d)) < N:
pass
else:
tmp = [0] + sorted(d) + [24]
s = 13
for i in range(N+1):
s = min(s, tmp[i+1]-tmp[i])
ans = max(ans, s)
print(ans)
| from collections import Counter
import itertools
N = int(eval(input()))
D = list(map(int, input().split()))
D.append(12)
M = Counter(D)
if max(M.values()) > 2:
print((0))
elif 0 in D:
print((0))
elif N > 11:
print((1))
else:
D.remove(12)
D = [[x, 24-x] for x in D]
generator = list(itertools.product([0, 1], repeat=N))
D_gen = [[D[i][g[i]] for i in range(N)] for g in generator]
ans = 0
for d in D_gen:
if len(set(d)) < N:
pass
else:
tmp = [0] + sorted(d) + [24]
s = 13
for i in range(N+1):
s = min(s, tmp[i+1]-tmp[i])
ans = max(ans, s)
print(ans)
| p03525 |
n,*d=list(map(int,open(0).read().split()));s=sorted
l=[0]+s([x if i%2 else 24-x for i,x in enumerate(s(d))])+[24]
print((min(j-i for i,j in zip(l,l[1:])))) | _,d=open(0);s=sorted;l=[0]+s([x if i%2else 24-x for i,x in enumerate(s(list(map(int,d.split()))))])+[24];print((min(j-i for i,j in zip(l,l[1:])))) | p03525 |
_,d=open(0);s=sorted;l=[0]+s([x if i%2else 24-x for i,x in enumerate(s(list(map(int,d.split()))))])+[24];print((min(j-i for i,j in zip(l,l[1:])))) | _,d=open(0);s=sorted;l=s([(24-x,x)[i%2]for i,x in enumerate(s(list(map(int,d.split()))))]);print((min(j-i for i,j in zip([0]+l,l+[24])))) | p03525 |
n,t=open(0)
n=int(n)+1
d=[t if i%2else(24-t)%24for i,t in enumerate([0]+sorted(map(int,t.split())))]
print((min(abs(d[i]-d[j])for i in range(n)for j in range(i+1,n)))) | _,d=open(0);s=sorted;l=s((24-x,x)[i%2]for i,x in enumerate(s(list(map(int,d.split())))));print((min(j-i for i,j in zip([0]+l,l+[24])))) | p03525 |
n = int(eval(input()))
d = list(map(int, input().split()))
h = [0]*13
for i in d:
h[i] += 1
ans = 0
def rec(now, state):
global ans
if now == 13:
state.sort()
m = float("Inf")
for i in range(len(state)):
m = min(m, min(abs(state[i-1]-state[i]), 24-abs(state[i-1]-state[i])))
ans = max(ans, m)
elif now == 0:
if h[now]:
return
rec(now+1, state)
elif now == 12:
if h[now]==0:
rec(now+1, state)
elif h[now]==1:
state.append(now)
rec(now+1, state)
else:
if h[now]==0:
rec(now+1, state)
elif h[now]==1:
s = state[:]
s.append(now)
rec(now+1,s)
s = state[:]
s.append(24-now)
rec(now+1, s)
elif h[now]==2:
state.append(now)
state.append(24-now)
rec(now+1, state)
rec(0, [0])
print(ans) | n = int(eval(input()))
a = [0]*13
for i in map(int, input().split()):
a[i] += 1
ans = 0
if any(i>2 for i in a) or a[0] or a[12]>1:
pass
else:
s = [[0]]
for i in range(1, 13):
nxt = []
if a[i] == 0:
nxt = s
elif a[i] == 1:
for si in s:
nxt.append(si+[i])
nxt.append(si+[24-i])
else:
for si in s:
nxt.append(si+[i, 24-i])
s = nxt
for si in s:
si.sort()
tmp = float("Inf")
for i in range(len(si)):
k = abs(si[i]-si[i-1])
k = min(k, 24-k)
tmp = min(tmp, k)
ans = max(ans, tmp)
print(ans) | p03525 |
def ans_is_zero():
print((0))
exit(0)
def solve():
n=int(eval(input()))
if n > 23: ans_is_zero()
d=list(map(int,input().split()))
for num in d:
if num == 0: ans_is_zero()
ans=0
N = 1 << n
for i in range(N):#left or right
t=1
for j in range(n):
if (i>>j)&1: t |= (1 << d[j])
else: t |= (1 << (24 - d[j]))
if bin(t).count("1") < n + 1:#重複あり
continue
ret = 100
prev = 0
for j in range(1, 24):
if ((t>>j)&1) == 0: continue
ret = min(ret, j - prev)
prev = j
ret = min(ret, 24-prev)
ans = max(ans, ret)
print(ans)
solve()
| def ans_is_zero():
print((0))
exit(0)
def solve():
n=int(eval(input()))
if n > 23: ans_is_zero()
d=list(map(int,input().split()))
for num in d:
if num == 0: ans_is_zero()
ans=0
N = 1 << n
for i in range(N):#left or right
t=1
ret = 100
for j in range(n):
if (i>>j)&1: num = d[j]
else: num = 24 - d[j]
if (t >> num)&1:
ret = -1
break
t |= (1 << num)
if ret == -1:
continue
if bin(t).count("1") < n + 1:#重複あり
continue
prev = 0
for j in range(1, 24):
if ((t>>j)&1) == 0: continue
ret = min(ret, j - prev)
prev = j
ret = min(ret, 24-prev)
ans = max(ans, ret)
print(ans)
solve()
| p03525 |
import random
def ans_is_zero():
print((0))
exit(0)
def solve():
n=int(eval(input()))
if n > 23: ans_is_zero()
d=list(map(int,input().split()))
for num in d:
if num == 0: ans_is_zero()
ans=0
random.shuffle(d)
N = 1 << n
for i in range(N):#left or right
t=1
ret = 100
for j in range(n):
if (i>>j)&1: num = d[j]
else: num = 24 - d[j]
if (t >> num)&1:
ret = -1
break
t |= (1 << num)
if ret == -1:
continue
if bin(t).count("1") < n + 1:#重複あり
continue
prev = 0
for j in range(1, 24):
if ((t>>j)&1) == 0: continue
ret = min(ret, j - prev)
prev = j
ret = min(ret, 24-prev)
ans = max(ans, ret)
print(ans)
solve()
|
def ans_is_zero():
print((0))
exit(0)
def solve():
n=int(eval(input()))
if n > 23: ans_is_zero()
d=list(map(int,input().split()))
for num in d:
if num == 0: ans_is_zero()
ans=0
d.sort()
N = 1 << n
for i in range(N):#left or right
t=1
ret = 100
for j in range(n):
if (i>>j)&1: num = d[j]
else: num = 24 - d[j]
if (t >> num)&1:
ret = -1
break
t |= (1 << num)
if ret == -1: continue
prev = 0
for j in range(1, 24):
if ((t>>j)&1) == 0: continue
ret = min(ret, j - prev)
prev = j
ret = min(ret, 24-prev)
ans = max(ans, ret)
print(ans)
solve()
| p03525 |
N = int(eval(input()))
D = [0] + list(map(int, input().split()))
Diffs = [[[0, 0] for i in range(N+1)] for j in range(N+1)]
# ある都市間の時差の取りうる値は2種類のみ
# 先ずはそれを全列挙
candidates = []
for i in range(N+1):
for j in range(i+1, N+1):
di, dj = D[i], D[j]
diff1, diff2 = abs(di-dj), min(24-di-dj, di+dj)
candidates.extend([[i, j, diff1, 0], [i, j, diff2, 1]])
Diffs[i][j] = [diff1, diff2]
# 上で全列挙した時差に関して、その時差が全体の最小値となり得るかどうかを確認していく
# 最小値となり得るかどうかを確認したい時差の値をdiffとすると、
# 任意の2都市間の時差がdiff以上となる必要があり、そのような時間の設定方法があるかどうかを確認する
# 矛盾するかどうかは都市を2色で塗り分ける要領で確認できる
ans = 0
for idx1, idx2, diff, c in candidates:
conditions = [-1] * (N+1)
if c == 0:
conditions[idx1] = conditions[idx2] = 0
else:
conditions[idx1] = 0; conditions[idx2] = 1
res = True
for i in range(N+1):
for j in range(i+1, N+1):
if idx1 == i and idx2 == j:
continue
diff1, diff2 = Diffs[i][j]
if diff1 < diff and diff2 < diff:
res = False
break
elif diff1 < diff:
c1, c2 = conditions[i], conditions[j]
if c1 < 0 and c2 < 0:
conditions[i] = 0; conditions[j] = 1
elif c1 < 0:
conditions[i] = 1 - c2
elif c2 < 0:
conditions[j] = 1 - c1
else:
if c1 == c2:
res = False
break
elif diff2 < diff:
c1, c2 = conditions[i], conditions[j]
if c1 < 0 and c2 < 0:
conditions[i] = conditions[j] = 0
elif c1 < 0:
conditions[i] = c2
elif c2 < 0:
conditions[j] = c1
else:
if c1 != c2:
res = False
break
else:
continue
break
if res:
ans = max(ans, diff)
print(ans) | # 想定解法
N = int(eval(input()))
D = list(map(int, input().split()))
num_time = [0] * 13
num_time[0] = 2
num_time[12] = 1
fixed = [0]
unfixed = []
for d in D:
num_time[d] += 1
if d == 12:
fixed.append(12)
if num_time[d] >= 3:
print((0))
quit()
for t in range(1, 12):
if num_time[t] == 2:
fixed.extend([t, 24 - t])
elif num_time[t] == 1:
unfixed.append(t)
ans = 0
n = len(unfixed)
for i in range(2**n):
t = fixed.copy() + [24]
# bitが0のものはt, 1のものは24-tとして設定する
for j in range(n):
if i >> j & 1:
t.append(unfixed[j])
else:
t.append(24 - unfixed[j])
t.sort()
s = 24
m = len(t)
for k in range(m-1):
_s = t[k+1] - t[k]
s = min(s, _s)
ans = max(ans, s)
print(ans) | p03525 |
import collections
from collections import deque
N=int(eval(input()))
D=list(map(int,input().split()))
c=collections.Counter(D)
count0=0
count12=0
zeroflag=0
l=[]
if c[12]>0:
count12=c[12]
if c[0]>0:
count0=c[0]+1
#print(l,count0,count12)
#print(n)
allmax=0
q=deque()
l=[]
if (count0==0)and(zeroflag==0):
q.append([0])
q.append([24])
elif (count0==1)and(zeroflag==0):
q.append([0,0])
q.append([0,24])
q.append([24,24])
else:
zeroflag=1
if (count12==1)and(zeroflag==0):
length=len(q)
j=0
while j<length:
buf1=[]
l=q.popleft()
buf1.extend(l)
l.append(12)
q.append(l)
j=j+1
elif count12>1:
zeroflag=1
if zeroflag==0:
for i in range(1,12):
length=len(q)
j=0
if c[i]==0: continue
if c[i]==1:
while j<length:
buf1=[]
buf2=[]
l=q.popleft()
buf1.extend(l)
buf1.append(i)
buf2.extend(l)
buf2.append(24-i)
q.append(buf1)
q.append(buf2)
j=j+1
if c[i]==2:
while j<length:
buf1=[]
buf2=[]
buf3=[]
l=q.popleft()
buf1.extend(l)
buf1.extend([i,i])
buf2.extend(l)
buf2.extend([24-i,24-i])
buf3.extend(l)
buf3.extend([i,24-i])
q.append(buf1)
q.append(buf2)
q.append(buf3)
j=j+1
if c[i]>2:
zeroflag=1
break
#print(q)
#print(q)
if zeroflag==0:
for l in q:
l.sort()
mi=100
n=len(l)
for j in range(n-1):
mi=min(mi,l[j+1]-l[j],24-l[j+1]+l[j])
mi=min(mi,l[n-1],24-l[n-1])
#print(mi)
allmax=max(allmax,mi)
else:
allmax=0
print(allmax)
"""
for i in range(pow(2,n)):
buf=[0]
bit=[0]*n
mi=100
if count12==1:
buf.append(12)
buf.append(0)
for j in range(n):
if (i>>j)&1:
bit[j]=1
#print(bit)
for j in range(n):
buf.append(l[j][bit[j]])
buf.sort()
buf.append(24)
#print(buf)
for j in range(len(buf)-1):
mi=min(mi,buf[j+1]-buf[j])
allmax=max(allmax,mi)
print(allmax)
"""
| import collections
from collections import deque
N=int(eval(input()))
D=list(map(int,input().split()))
c=collections.Counter(D)
count0=0
count12=0
zeroflag=0
l=[]
if c[12]>0:
count12=c[12]
if c[0]>0:
count0=c[0]+1
#print(l,count0,count12)
#print(n)
allmax=0
q=deque()
l=[]
if (count0==0)and(zeroflag==0):
q.append([0])
else:
zeroflag=1
if (count12==1)and(zeroflag==0):
length=len(q)
j=0
while j<length:
buf1=[]
l=q.popleft()
buf1.extend(l)
l.append(12)
q.append(l)
j=j+1
elif count12>1:
zeroflag=1
if zeroflag==0:
for i in range(1,12):
length=len(q)
j=0
if c[i]==0: continue
if c[i]==1:
while j<length:
buf1=[]
buf2=[]
l=q.popleft()
buf1.extend(l)
buf1.append(i)
buf2.extend(l)
buf2.append(24-i)
q.append(buf1)
q.append(buf2)
j=j+1
if c[i]==2:
while j<length:
buf1=[]
buf2=[]
buf3=[]
l=q.popleft()
#buf1.extend(l)
#buf1.extend([i,i])
#buf2.extend(l)
#buf2.extend([24-i,24-i])
buf3.extend(l)
buf3.extend([i,24-i])
#q.append(buf1)
#q.append(buf2)
q.append(buf3)
j=j+1
if c[i]>2:
zeroflag=1
break
#print(q)
#print(q)
if zeroflag==0:
for l in q:
l.sort()
mi=100
n=len(l)
for j in range(n-1):
mi=min(mi,l[j+1]-l[j],24-l[j+1]+l[j])
mi=min(mi,l[n-1],24-l[n-1])
#print(mi)
allmax=max(allmax,mi)
else:
allmax=0
print(allmax)
| p03525 |
n, c, k = list(map(int, input().split()))
t = []
for i in range(n):
t.append(int(eval(input())))
t.sort()
result = 1
count = 0
for i in range(n):
if (t[count] - t[0]) > k or c == count:
result += 1
t = t[count:]
count = 1
else:
count += 1
print(result) | n, c, k = list(map(int, input().split()))
t = [int(eval(input())) for i in range(n)]
t.sort()
result = 1
count = 0
f = 0
for i in range(n):
if (t[i] - t[f]) > k or c == count:
result += 1
count = 1
f = i
else:
count += 1
print(result) | p03785 |
def ii():return int(eval(input()))
def iim():return list(map(int,input().split()))
def iil():return list(map(int,input().split()))
n,c,k = iim()
time = []
for _ in range(n):
time.append(ii())
time.sort()
bus = 0
fst = time[0]
ans = 0
for item in time:
if bus <= c-1 and item <= k+fst:
bus += 1
elif bus > c-1:
bus = 1
ans += 1
fst = item
elif item-fst > k:
bus = 1
ans += 1
fst = item
print((ans if bus == 0 else ans+1)) | def ii():return int(eval(input()))
def iim():return list(map(int,input().split()))
def iil():return list(map(int,input().split()))
n,c,k = iim()
time = []
for _ in range(n):
time.append(ii())
time.sort()
bus = 0
fst = time[0]
ans = 0
for item in time:
if bus <= c-1 and item <= k+fst:
bus += 1
else:
bus = 1
ans += 1
fst = item
print((ans if bus == 0 else ans+1)) | p03785 |
import math
N, C, K = list(map(int, input().split()))
t_dic = {}
for j in range(N):
t_num = int(eval(input()))
num = t_dic.get(t_num, 0)
t_dic[t_num] = num + 1
t_list = sorted(t_dic.keys())
removed_man_dic = {}
total_car = 0
for i, t in enumerate(t_list):
limit = t + K
limit_num = t_dic[t] - removed_man_dic.get(t, 0)
if limit_num == 0:
continue
car_num = int(math.ceil(limit_num / C))
total_car += car_num
passenger = C * car_num
remaining_seat = passenger - limit_num
removed_man_dic = {}
for j in t_list[i+1:]:
if j >= limit:
break
num = t_dic.get(j, 0)
if num <= remaining_seat:
remaining_seat -= num
removed_man_dic[j] = num
else:
removed_man_dic[j] = remaining_seat
break
print(total_car)
| N, C, K = list(map(int, input().split()))
t_sorted = [int(eval(input())) for _ in range(N)]
t_sorted.sort()
car = 0
passenger = 0
target_t, limit = 0, 0
for i, t in enumerate(t_sorted):
if target_t == 0:
target_t = t
limit = t + K
passenger += 1
if passenger == C:
car += 1
passenger = 0
target_t = 0
continue
if i != N - 1:
if t_sorted[i + 1] > limit:
car += 1
passenger = 0
target_t = 0
continue
if passenger > 0:
car += 1
print(car)
| p03785 |
N, C, K = list(map(int, input().split()))
T = []
for i in range(N):
T.append(int(eval(input())))
sorted_T = sorted(T)
bus_count = 1
pas_count = 0
bus_start = sorted_T[0]
for t in sorted_T:
if pas_count == C or t - bus_start > K:
bus_count += 1
pas_count = 0
bus_start = t
pas_count += 1
print(bus_count) | N, C, K = list(map(int, input().split()))
flag = True
pass_num = 0
count = 1
for t in sorted([int(eval(input())) for _ in range(N)]):
if flag:
first_pass_time = t
flag = False
if t - first_pass_time > K or pass_num == C:
first_pass_time = t
pass_num = 0
count += 1
pass_num += 1
print(count) | p03785 |
import bisect
N, C, K = list(map(int, input().split()))
T = sorted([int(eval(input())) for i in range(N)])
i = 0
ans = 0
while T:
ans += 1
check = T[0] + K
people = bisect.bisect_right(T, check)
if people > C:
del T[:C]
else:
del T[:people]
print(ans) | import bisect
N, C, K =list(map(int, input().split()))
T = sorted([int(eval(input())) for i in range(N)])
ans = 0
front = 0
while front < N:
standard = T[front] + K
front = min(bisect.bisect_right(T, standard), front+C)
ans += 1
print(ans) | p03785 |
# AGC011A - Airport Bus
import sys
input = sys.stdin.readline
def main():
N, C, K = tuple(map(int, input().rstrip().split()))
T = sorted(map(int, [input().rstrip() for _ in range(N)]))
ans, cur, cnt = 0, T[0] + K, 0
for i in T:
if i > cur or cnt == C: # need a new bus
cur = i + K
cnt = 1
ans += 1
else: # ride on the current bus
cnt += 1
print((ans + 1))
if __name__ == "__main__":
main() | # AGC011A - Airport Bus
def main():
N, C, K, *T = list(map(int, open(0).read().split()))
T.sort()
ans, cur, cnt = 0, T[0] + K, 0
for i in T:
if i > cur or cnt == C: # need a new bus
cur = i + K
cnt = 1
ans += 1
else: # ride on the current one
cnt += 1
print((ans + 1))
if __name__ == "__main__":
main() | p03785 |
N,C,K = list(map(int,input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
i = 0
ans = 0
while i < N:
tmp = i+1
while tmp < N:
if tmp < i+C and T[tmp] <= T[i]+K:
tmp += 1
else:
break
ans += 1
i = tmp
print(ans) | N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
T.append(10**12)
ans = 0
now = T[0]
i = 0
while i < N:
ans += 1
num = 0
while i < N and T[i] <= now+K and num < C:
num += 1
i += 1
now = T[i]
print(ans)
| p03785 |
import sys
input = sys.stdin.readline
N,C,K = list(map(int,input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
answer = 0
first = -K
rest = C
for t in T:
if first + K >= t and rest > 0:
# 乗れる
rest -= 1
continue
# 乗れない
answer += 1
first = t
rest = C-1
print(answer) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# greedy
N,C,K,*T = list(map(int,read().split()))
T.sort()
bus_t = -K - 100
bus_c = C
answer = 0
for t in T:
bl = (bus_t + K >= t) and (bus_c + 1 <= C)
if bl:
bus_c += 1
continue
answer += 1
bus_t = t
bus_c = 1
print(answer) | p03785 |
import bisect
kyaku, teiin, jikan = list(map(int, input().split(" ")))
a=sorted([(int)(eval(input())) for i in range(kyaku)])
count = 0
while(True):
#print(a)
if len(a) > teiin:
if a[0] + jikan >= a[teiin]:
a = a[teiin:]
else:
a = a[bisect.bisect_left(a, a[0] + jikan):]
else:
if a[0] + jikan >= a[-1]:
count += 1
break
else:
a = a[bisect.bisect_left(a, a[0] + jikan):]
count += 1
print(count) | n,c,k = list(map(int ,input().split(" ")))
t = sorted([int(eval(input())) for i in range(n)])
total = 0
count = 0
while(count != n):
temp = 0
#print(count, total)
for i in range(c):
if count + i >= n:
#print("乗りたい人数を全部さばいた")
if t[-1] - t[count] <= k:
#print("最後の人全員載せる")
count = n
total += 1
break
else:
temp = 0
while(count != n):
#print("残りを何回で載せられるか")
if t[count + temp] - t[count] <= k:
temp += 1
else:
count += temp + 1
total += 1
break
break
if t[count + i] - t[count] > k:
#print("定員を超えた")
count += i
total += 1
break
else:
#print("k人全員載せる")
count += c
total += 1
if count == n:
break
print(total) | p03785 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
from bisect import bisect_left, bisect_right
def main():
N,C,K = list(map(int, input().split()))
Ti = list(int(eval(input())) for _ in range(N))
Ti.sort()
ret = 0
# print(Ti)
while len(Ti)>0:
Tto = K + Ti[0]
Ti = Ti[min(C,bisect_right(Ti[:min(C,len(Ti))], Tto)):]
ret += 1
# print(Ti)
print(ret)
if __name__ == '__main__':
main() | #!/usr/bin python3
# -*- coding: utf-8 -*-
from bisect import bisect_left, bisect_right
def main():
N,C,K = list(map(int, input().split()))
Ti = list(int(eval(input())) for _ in range(N))
Ti.sort()
i = 0
ret = 0
while i<N:
ret += 1
s = i
Ts = Ti[i]
while i<N and Ti[i]<=(Ts+K) and (i-s)<C:
i += 1
print(ret)
if __name__ == '__main__':
main() | p03785 |
def main():
n, c, k, *t = list(map(int, open(0).read().split()))
t = sorted(t)
u = tuple(t)
count = 0
i = 0
while i < n:
x = u[i] + k
y = min(i + c - 1, n - 1)
while True:
if u[y] <= x:
break
y -= 1
count += 1
i = y + 1
print(count)
if __name__ == '__main__':
main()
| def main():
n, c, k, *t = list(map(int, open(0).read().split()))
t = sorted(t)
u = tuple(t)
cnt = 1
p, l = 0, u[0] + k
for v in t:
if v <= l and p < c:
p += 1
else:
cnt += 1
l = v + k
p = 1
print(cnt)
if __name__ == '__main__':
main()
| p03785 |
def main():
n, c, k, *t = list(map(int, open(0).read().split()))
t = sorted(t)
u = tuple(t)
cnt = 1
p, l = 0, u[0] + k
for v in t:
if v <= l and p < c:
p += 1
else:
cnt += 1
l = v + k
p = 1
print(cnt)
if __name__ == '__main__':
main()
| def main():
n, c, k, *t = list(map(int, open(0).read().split()))
t.sort()
u = tuple(t)
cnt = 1
p, l = 0, u[0] + k
for v in t:
if v <= l and p < c:
p += 1
else:
cnt += 1
p = 1
l = v + k
print(cnt)
if __name__ == '__main__':
main()
| p03785 |
import bisect
def resolve():
n, c, k = list(map(int, input().split()))
t = list(int(eval(input())) for _ in range(n))
t.sort()
ans = 0
while t:
candidates = bisect.bisect_left(t, t[0] + k)
# candidates = len([tj for tj in t if tj <= t[0] + k])
num = min(c, candidates)
t = t[num:]
ans += 1
print(ans)
if __name__ == "__main__":
resolve()
| def resolve():
n, c, k = list(map(int, input().split()))
t = list(int(eval(input())) for _ in range(n))
t.sort()
ans = 1
limit = t[0] + k
bus = 0
for i in range(n):
bus += 1
if t[i] > limit or bus > c:
limit = t[i] + k
ans += 1
bus = 1
print(ans)
if __name__ == "__main__":
resolve()
| p03785 |
import sys
def input():
return sys.stdin.readline()[:-1]
N, C, K = list(map(int, input().split()))
T = [0]*N
for i in range(N):
T[i] = int(eval(input()))
T.sort()
ans = 0
bus_time = -1
bus_num = 0
for i in range(N):
# 新しいバス
if bus_time == -1:
bus_time = T[i]
bus_num = 1
ans += 1
elif T[i] <= bus_time+K and bus_num <= C:
bus_num += 1
else:
bus_time = T[i]
bus_num = 1
ans += 1
if bus_num == C:
bus_time = -1
bus_num = 0
print(ans)
| import sys
def input():
return sys.stdin.readline()[:-1]
N, C, K = list(map(int, input().split()))
T = [0]*N
for i in range(N):
T[i] = int(eval(input()))
T.sort()
ans = 1
bus_time = T[0]
bus_num = 0
for i in range(N):
if T[i] <= bus_time+K and bus_num < C:
# 止まっているバスに乗る
bus_num += 1
else:
# 新しいバスが必要
bus_time = T[i]
bus_num = 1
ans += 1
print(ans)
| p03785 |
N, C, K = [int(x) for x in input().split()]
T = [int(eval(input())) for _ in range(N)]
T.sort()
depart = T[0] + K # 出発時刻
passenger = 0 # 乗客数
bus = 1
for i in range(N):
if passenger >= C or depart < T[i]: # すでに満員または待ち時間オーバー
bus += 1
passenger = 1
depart = T[i] + K
else:
passenger += 1
print(bus) | import sys
input = sys.stdin.readline
N, C, K = [int(x) for x in input().split()]
T = [int(eval(input())) for _ in range(N)]
T.sort()
depart = T[0] + K # 出発時刻
passenger = 0 # 乗客数
bus = 1
for i in range(N):
if passenger >= C or depart < T[i]: # すでに満員または待ち時間オーバー
bus += 1
passenger = 1
depart = T[i] + K
else:
passenger += 1
print(bus) | p03785 |
N,C,K = list(map(int,input().split()))
T = []
for i in range(N):
T.append(int(eval(input())))
flag = 0
ans = 1
T = sorted(T)
while flag == 0:
if C < len(T) or T[-1]-T[0]>=K:
if C < len(T):
if T[0]+K<T[C-1]:
T = [i for i in T if i > T[0]+K]
ans += 1
else:
T = T[C:]
ans += 1
else:
T = [i for i in T if i > T[0]+K]
ans += 1
else:
flag = 1
print(ans) | N,C,K=list(map(int,input().split()))
T=[]
for i in range(N):
p=int(eval(input()))
T.append(p)
ans = 1
T = sorted(T)
ind = 0
for i in range(len(T)):
if T[i] > T[ind]+K:
ans += 1
ind = i
elif i >= ind + C:
ans += 1
ind = i
print(ans) | p03785 |
import collections
n, c, k = list(map(int, input().split()))
t = [int(eval(input())) for i in range(n)]
t.sort()
passenger = 0
departure_limit = t[0] + k
bus_cnt = 0
for T in t:
if passenger+1 > c or T > departure_limit:
departure_limit = T+k
passenger = 1
bus_cnt += 1
else:
passenger+=1
print((bus_cnt+1)) | n, c, k, *t = list(map(int, open(0).read().split()))
t.sort()
tmp = 0
cnt = 0
limit = t[0] + k
for time in t:
if tmp == c or time > limit:
limit = time + k
tmp = 1
cnt += 1
else:
tmp += 1
print((cnt + 1)) | p03785 |
n,c,k = list(map(int, input().split()))
t = [int(eval(input())) for _ in range(n)]
t.sort()
T = 0
cnt = 0
ans = 0
for i in range(n):
if cnt == 0: #誰も待っていない
T = t[i] + k
cnt += 1
elif t[i] <= T:
cnt += 1
elif t[i] > T:
ans += 1
cnt = 1
T = t[i] + k
if cnt == c:
ans += 1
T = 0
cnt = 0
if cnt != 0: ans += 1
print(ans) | n,c,k = list(map(int, input().split()))
t = sorted(list(int(eval(input())) for _ in range(n)))
#Ti以上Ti+k以下のバスに乗る
#定員はC人
T = 0
cnt = 0
bus = 0
for i in range(n):
if cnt == 0:
cnt += 1
T = t[i] + k
elif T >= t[i]:
cnt += 1
elif T < t[i]:
bus += 1
cnt = 1
T = t[i]+k
if cnt == c:
bus += 1
T = 0
cnt = 0
if cnt != 0: bus += 1
print(bus) | p03785 |
n,c,k = [int(x) for x in input().split()]
t = []
for _ in range(n):
t.append(int(eval(input())))
t.sort()
ans = 0
tmp = {"f": 0, "num": c}
for x in t:
if tmp["f"] >= x and tmp["num"] > 0:
tmp["num"] -= 1
else:
ans += 1
tmp["num"] = c-1
tmp["f"] = x+k
print(ans)
| n,c,k = [int(x) for x in input().split()]
t = [int(eval(input())) for _ in range(n)]
t.sort()
bus = c
f_bus = 0
ans = 0
for i in range(n):
if t[i] > f_bus or bus == 0:
ans += 1
f_bus = t[i]+k
bus = c-1
else:
bus -= 1
print(ans) | p03785 |
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
answer = 0
while len(T) > 0:
limit = T[0] + K
counter = 0
while counter < C:
if len(T) == 0:
break
if T[0] > limit:
break
del T[0]
counter += 1
answer += 1
print(answer)
| N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
limit = T[0]
answer = 1
counter = 1
for i in range(1,N):
if T[i] - limit > K or counter == C:
limit = T[i]
counter = 1
answer += 1
else:
counter += 1
print(answer) | p03785 |
def main() -> None:
n, c, k = list(map(int, input().split()))
t = [int(eval(input())) for _ in range(n)]
ans = wait_start = wait_people = 0
for ti in sorted(t):
if ti - wait_start > k or wait_people == c:
wait_people = 0
wait_people += 1
if wait_people == 1:
wait_start = ti
ans += 1
print(ans)
if __name__ == '__main__':
main()
| import sys
def main() -> None:
n, c, k = list(map(int, input().split()))
t = [int(sys.stdin.readline()) for _ in range(n)]
ans = wait_start = wait_people = 0
for ti in sorted(t):
if ti - wait_start > k or wait_people == c:
wait_people = 0
wait_people += 1
if wait_people == 1:
wait_start = ti
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03785 |
N, C, K = list(map(int, input().split()))
T = []
for _ in range(N):
T.append(int(eval(input())))
T.sort()
buss = []
x, *T = T
bus = [x]
while T:
while T:
t, *T = T
if t <= x + K and len(bus) < C:
bus.append(t)
else:
x = t
buss.append(bus)
bus = [x]
break
buss.append(bus)
print((len(buss))) | N, C, K = list(map(int, input().split()))
T = sorted([int(eval(input())) for _ in range(N)])
x = T[0]
p = 1
b = 1
for i in range(1, N):
if T[i] <= x + K and p < C:
p += 1
else:
x = T[i]
b += 1
p = 1
print(b) | p03785 |
n, c, k = list(map(int, input().split()))
arr = [eval(input()) for i in range(n)]
arr.sort()
res = 1
start = arr[0]
cur = c
for pas in arr:
if c == 0:
c = cur
start = pas
res += 1
if pas <= start + k:
c -= 1
else:
res += 1
c = cur -1
start = pas
print(res)
| n, c, k = list(map(int, input().split()))
arr = [eval(input()) for i in range(n)]
arr.sort()
res = 1
start = arr[0]
cur = c
for pas in arr:
if c == 0:
c = cur - 1
start = pas
res += 1
continue
if pas <= start + k:
c -= 1
else:
res += 1
c = cur -1
start = pas
print(res)
| p03785 |
n,c,k = list(map(int,input().split()))
t = list(int(eval(input())) for i in range(n))
t.sort()
ans = 0
i = 0
while i < n:
a = t[i]
j = i + 1
z = 1
for j in range(i+1,min(i+c,n)):
if a+k >= t[j]:
z += 1
else:
break
i += z
ans += 1
print(ans) | n,c,k = list(map(int,input().split()))
t = list(int(eval(input())) for i in range(n))
t.sort()
ans = 0
x = t[0]
y = 1
for i in range(1,n):
if x+k < t[i] or y >= c:
ans += 1
x = t[i]
y = 1
else:
y += 1
print((ans+1)) | p03785 |
N, C, K = list(map(int, input().split()))
T = sorted([int(eval(input())) for i in range(N)])
array = [T[0]]
arrays = []
s = 0
for i in range(1, len(T)):
if ((T[i] - T[s]) <= K) and len(array) < C:
array.append(T[i])
else:
arrays.append(array)
array = [T[i]]
s = i
print((len(arrays + [array]))) | N, C, K = list(map(int, input().split()))
T = sorted([int(eval(input())) for i in range(N)])
s = 0
array = [T[0]]
arrays = []
for i in range(1, N):
if ((T[i] - T[s]) <= K) and (len(array) < C):
array.append(T[i])
else:
arrays.append(array)
array = [T[i]]
s = i
print((len(arrays + [array]))) | p03785 |
N, C, K = list(map(int, input().split()))
T = []
for _ in range(N):
T.append((int(eval(input())), False))
T.append((T[-1][0] + K, True))
T.sort(key=lambda x: (x[0], x[1]))
ans = 0
arrived = 0
head = 0
for t, bo in T:
if arrived == 0 and not bo:
head = t
arrived += not bo
if (bo and arrived > 0 and head <= t - K) or arrived == C:
arrived = 0
ans += 1
head = 2000000009
if arrived > 0:
ans += 1
print(ans) | N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
ans = 0
first = T[0]
arrived = 0
for t in T:
if first + K < t or arrived == C:
ans += 1
arrived = 0
first = t
arrived += 1
print((ans + (arrived > 0))) | p03785 |
# 乗せれるだけ乗っけるのがいいと思うだけなんだけどどうなんでしょう
# なんか実装しにくい 世界一プログラミングが下手
# 二重whileなんてやるからだ forでいいやろ
n, c, k = list(map(int, input().split()))
ans = 0
arr = sorted([int(eval(input())) for _ in range(n)])
cur_passenger = 0
limit = arr[0] + k
for i in range(n):
if cur_passenger < c and arr[i] <= limit:
cur_passenger += 1
# print("{}番目の人は{}のバスに乗せた".format(i, ans))
else:
cur_passenger = 1
limit = arr[i] + k
ans += 1
# print("{}番目の人を{}のバスの最初の客にした".format(i, ans))
# あぶれた人を救済
if cur_passenger > 0:
ans += 1
print(ans)
| n, c, k = list(map(int, input().split()))
t = sorted([int(eval(input())) for _ in range(n)])
ans = 1
passenger = 0
limit = t[0] + k
for p in t:
if passenger < c and p <= limit:
passenger += 1
else:
ans += 1
passenger = 1
limit = p + k
print(ans)
| p03785 |
N, C, K = list(map(int, input().split()))
passengers = sorted([int(eval(input())) for i in range(N)])
res = {}
for p in passengers:
key = False
for k in list(res.keys()):
if k <= p and p <= k + K and res[k] <= C - 1:
res[k] += 1
key = True
break
if not key:
res[p] = 1
print((len(res)))
| N, C, K = list(map(int, input().split()))
passengers = sorted([int(eval(input())) for i in range(N)])
res = 0
bus_time = passengers[0]
bus_count = C
for p in passengers:
if bus_count == 0 or p - bus_time > K:
res += 1
bus_time = p
bus_count = C - 1
else:
bus_count -= 1
if bus_count != C:
res += 1
print(res)
| p03785 |
# -*- coding: utf-8 -*-
#----------
N,C,K = list(map(int, input().rstrip().split()))
T_list = [int(input().strip()) for _ in range(N)]
T_list.sort()
#----------
num_bus=0
i=0
while i < len(T_list):
# Busに何人乗せられるか時刻を比較
member_bus=0
break_flg=False
for j in range(C):
if (i+j) < len(T_list):
if T_list[i+j] <= (T_list[i] + K):
member_bus += 1
num_bus += 1
i = i + member_bus
print(num_bus)
| # -*- coding: utf-8 -*-
#----------
N,C,K = list(map(int, input().rstrip().split()))
T_list = [int(input().strip()) for _ in range(N)]
T_list.sort()
#----------
num_bus=0
i=0
while i < len(T_list):
# Busに何人乗せられるか時刻を比較
member_bus=0
break_flg=False
for j in range(C):
if (i+j) < len(T_list):
if T_list[i+j] <= (T_list[i] + K):
member_bus += 1
else:
break_flg=True
else:
break_flg=True
if break_flg:
break
num_bus += 1
i = i + member_bus
print(num_bus)
| p03785 |
from collections import Counter
n, c, k = list(map(int, input().split()))
time_people = Counter([int(eval(input())) for _ in range(n)])
times = sorted(time_people.keys())
ans = 0
left = 0
right = 0
while time_people[times[-1]] > 0:
space = c
while times[left] + k >= times[right] and space > 0:
new_passenger = min(c, time_people[times[right]])
space -= new_passenger
time_people[times[right]] -= new_passenger
if right >= len(times):
break
if time_people[times[right]] == 0:
right += 1
if right == len(times):
break
ans += 1
while left < len(times) and time_people[times[left]] <= 0:
left += 1
print(ans) | n, c, k = list(map(int, input().split()))
T = sorted([int(eval(input())) for _ in range(n)])
ans = 1
first = T[0]
pas = 0
for t in T:
pas += 1
if t > first + k or pas > c:
ans += 1
pas = 1
first = t
print(ans) | p03785 |
n,c,k=list(map(int,input().split()))
t=[int(eval(input())) for _ in range(n)]+[10**10]
t.sort()
b=1
p=0
while p<n:
l=t[p]+k
pp=1
f=1
while pp<c and f:
p+=1
if t[p]<=l:
pp+=1
if pp==c:
p+=1
else:
f=0
if p<n:
b+=1
print(b) | n,c,k=list(map(int,input().split()))
t=[int(eval(input())) for _ in range(n)]+[10**10]
t.sort()
b=1
p=0
if c==1:
print(n)
exit()
while p<n:
l=t[p]+k
pp=1
f=1
while pp<c and f:
p+=1
if t[p]<=l:
pp+=1
if pp==c:
p+=1
else:
f=0
if p<n:
b+=1
print(b) | p03785 |
n,c,k = list(map(int, input().split()))
Ts = [int(eval(input())) for i in range(n)] + [10**10]
Ts = sorted(Ts)
ans = 0
cnt = 1
flg = 0
prev = Ts[0]
for i in range(1,len(Ts)):
now = Ts[i]
if now - prev <= k:
cnt += 1
else:
ans += 1
cnt = 1
prev = Ts[i]
if cnt > c:
ans += 1
cnt = 1
prev = Ts[i]
# print("i",i,"cnt",cnt,"ans",ans)
print(ans)
| import sys
input = sys.stdin.readline
n,c,k = list(map(int, input().split()))
ts = [int(eval(input())) for i in range(n)]
ts.sort()
cnt = 0
ans = 0
end = -1
for i, t in enumerate(ts):
if end < t:
cnt = 1
ans += 1
end = t + k
else: # t <= end
cnt += 1
if cnt > c:
cnt = 1
ans += 1
end = t + k
print(ans)
| p03785 |
n, c, k = list(map(int, input().split()))
t = [int(eval(input())) for _ in range(n)]
t = sorted(t)
cnt_bus = 0
i = 0
while i < n:
cnt_rider = 0
l, r = i, min(i + c - 1, n - 1)
while l <= r:#適当なmidを求める
mid = (l + r) // 2
if t[mid] > t[i] + k:
r = mid - 1
else:
#t[mid] <= t[i] + k
p = mid#最後に乗車する人の番号（仮）
l = mid + 1
cnt_rider = p - i + 1
i += cnt_rider
cnt_bus += 1
#print(p, cnt_rider)
print(cnt_bus) | n, c, k = list(map(int, input().split()))
ts = [int(eval(input())) for _ in range(n)]
ts = sorted(ts)
cnt = 0
rider = 0
limit = -1
for t in ts:
if (rider == c) or not(t <= limit <= (t + k)):
cnt += 1
limit = (t + k)
rider = 1
else:
rider += 1
print(cnt) | p03785 |
N, C, K = list(map(int, input().split()))
T = [0 for _ in range(N)]
for i in range(N):
T[i] = int(eval(input()))
T = sorted(T)
ans = 0
while T != []:
cnt = 0
for i in range(len(T)):
cnt += 1
if T[i] - T[0] > K or cnt > C:
T = T[i:]
ans += 1
break
if i == len(T)-1:
ans += 1
T = []
print(ans)
| N, C, K = list(map(int, input().split()))
T = [0 for _ in range(N)]
for i in range(N):
T[i] = int(eval(input()))
T = sorted(T)
flag = 0
cnt = 0
ans = 0
for i in range(len(T)):
time = T[i] - T[flag]
cnt += 1
if time > K or cnt > C:
flag = i
cnt = 1
ans += 1
print((ans + 1))
| p03785 |
N, C, K = list(map(int, input().split()))
users = []
for i in range(N):
users.append(int(eval(input())))
users = sorted(users, reverse=False)
ans = 0
pos = 0
start = 0
while True:
count = 0
if pos == N:
break
start = users[pos]
# print("start:{}".format(start))
for i in range(C):
if pos+i < N and users[pos+i] <= start+K:
count += 1
pos += count
# print("pos:{}".format(pos))
ans += 1
# print("ans:{}".format(ans))
print(ans) | N, C, K = list(map(int, input().split()))
users = []
for i in range(N):
users.append(int(eval(input())))
users = sorted(users, reverse=False)
ans = 0
pos = 0
start = 0
while True:
count = 0
if pos == N:
break
start = users[pos]
# print("start:{}".format(start))
for i in range(C):
if pos+i < N and users[pos+i] <= start+K:
count += 1
else:
break
pos += count
# print("pos:{}".format(pos))
ans += 1
# print("ans:{}".format(ans))
print(ans) | p03785 |
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
num_track = 0
i = 0
while i < N:
L = T[i]
if i + C + 1 < N:
kouho = T[i:i+C] # T[i],...,T[i+C-1]
else:
kouho = T[i:]
# <= L + K
num = 0
for j in range(len(kouho)):
if kouho[j] - L <= K:
num += 1
num_track += 1
i += num
print(num_track)
| N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
res = 0
i = 0
while i < N:
res += 1
Left = i
while (i < N and T[i] - T[Left] <= K and i - Left + 1 <= C):
i += 1
print(res)
| p03785 |
from collections import deque
n,c,k = list(map(int, input().split()))
t = [int(eval(input())) for _ in range(n)]
tk = [(ti, ti+k) for ti in t]
tk.sort(key=lambda x:x[1])
tk = deque(tk)
#print(tk)
ans = 0
# tkが尽きるまで
while tk:
_, bus = tk[0]
# バスの時刻より早く来ている客をカウント
cnt = 0
while (tk[cnt][0] <= bus) and (cnt < c):
cnt += 1
if cnt == len(tk):
break
# バスの定員もしくはいる人数を乗せていく
for _ in range(min(cnt,c)):
tk.popleft()
ans += 1
print(ans) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,c,k = li()
t = [ni() for _ in range(n)]
t.sort()
ans = 0
people = 0
isfirst = True
for ti in t:
if isfirst:
first = ti
people = 1
isfirst = False
else:
if ti <= first + k and people < c:
people += 1
else:
ans += 1
people = 1
first = ti
print((ans+1)) | p03785 |
from bisect import bisect_right
N,C,K = list(map(int,input().split()))
T = sorted([int(eval(input())) for _ in range(N)])
cnt = 0
cur = 0
while cur<N:
i = min(cur+C,N)-1
if T[i]-T[cur]<=K:
cnt += 1
cur = i+1
else:
i = bisect_right(T,T[cur]+K)-1
cnt += 1
cur = i+1
print(cnt) | from bisect import bisect_right
N,C,K = list(map(int,input().split()))
T = sorted([int(eval(input())) for _ in range(N)])
cur = 0
cnt = 0
while cur<N:
ind = bisect_right(T,T[cur]+K)
if ind-cur<=C:
cnt += 1
cur = ind
else:
cnt += 1
cur += C
print(cnt) | p03785 |
def solve():
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
cnt = 0
ans = 1
for i in range(N-1):
if i==0:
t = T[0]
cnt += 1
if T[i+1]>t+K or cnt>=C:
ans += 1
cnt = 0
t = T[i+1]
return ans
print((solve())) | def solve():
N, C, K = list(map(int, input().split()))
ans = 1
cnt = 0
T = [int(eval(input())) for _ in range(N)]
T.sort()
for i in range(N):
if i==0:
now = T[i]
cnt += 1
if now+K<T[i] or cnt>C:
ans += 1
cnt = 1
if i<N-1:
now = T[i]
return ans
print((solve())) | p03785 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, c, k = list(map(int, readline().split()))
t = sorted([int(readline()) for i in range(n)])
cnt = 0
ans = 1
time = t[0] + k
for i in range(n):
if cnt >= c or time < t[i]:
ans += 1
cnt = 0
time = t[i] + k
cnt += 1
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, c, k = list(map(int, readline().split()))
t = [int(readline()) for _ in range(n)]
t.sort()
ans = 1
tmp = [t[0], 0]
for tt in t:
if tmp[0] + k < tt or tmp[1] + 1 > c:
ans += 1
tmp = [tt, 0]
tmp[1] += 1
print(ans)
| p03785 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.