input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from collections import deque
N,M=list(map(int,input().split()))
even_list=[list(map(int,input().split())) for _ in range(M)]
#リストVのN番目には頂点Nがあり、そこには頂点Nとつながっている頂点が入っている。
#seen[i]は、頂点iを訪問済みの場合はTrue、未訪問の場合はFalse
seen=[False for i in range(N+1)]
count=0
graph=[[] for _ in range(N+1)]
for i in even_list:
graph[i[0]].append(i[1])
graph[i[1]].append(i[0])
def StackBFS(s):
#graphのN番目には頂点Nがあり、そこには頂点Nとつながっている頂点が入っている。
S=deque([s])
C=set()
while S:
v=S.popleft()
seen[v]=True #訪問済みの頂点をTrueにする
if v not in C:
C=C|{v}
for i in graph[v]:
S.append(i)
for i in range(1,N+1):
if seen[i]==False:
StackBFS(i)
count+=1
print(count) | from collections import deque
N,M=list(map(int,input().split()))
graph=[[] for _ in range(N+1)]
for _ in range(M):
a,b,c=list(map(int,input().split()))
graph[a].append(b)
graph[b].append(a)
#seen[i]は、頂点iを訪問済みの場合はTrue、未訪問の場合はFalse
seen=[False]*(N+1)
count=0
for i in range(1,N+1):
if seen[i]==False:
seen[i]=True
S=deque([i])
while S:
v=S.popleft()
#訪問済みの頂点をTrueにする
for i in graph[v]:
if seen[i]==False:
seen[i]=True
S.append(i)
count+=1
print(count) | p03045 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10**7)
n,m,*l=list(map(int,open(0).read().split()))
graph=[[]*n for _ in range(n)]
unvis=[True]*n
@lru_cache(maxsize=None)
def dfs(x):
for y in graph[x]:
if unvis[y]:
unvis[y]=False
dfs(y)
for i,j in zip(l[::3],l[1::3]):
graph[i-1].append(j-1)
graph[j-1].append(i-1)
ans=0
for x in range(n):
if unvis[x]:
unvis[x]=False
dfs(x)
ans+=1
print(ans)
| import sys
sys.setrecursionlimit(200000)
n,m,*l=list(map(int,open(0).read().split()))
graph=[[]*n for _ in range(n)]
unvis=[True]*n
def dfs(x):
for y in graph[x]:
if unvis[y]:
unvis[y]=False
dfs(y)
for i,j in zip(l[::3],l[1::3]):
graph[i-1].append(j-1)
graph[j-1].append(i-1)
ans=0
for x in range(n):
if unvis[x]:
unvis[x]=False
dfs(x)
ans+=1
print(ans)
| p03045 |
import collections
def main():
n,m = list(map(int,input().split()))
f = [False for _ in range(n)]
a = [[] for _ in range(n)]
res = 0
for _ in range(m):
x,y,z = list(map(int,input().split()))
a[x-1].append(y-1)
a[y-1].append(x-1)
for i in range(n):
if not f[i]:
res += 1
q=collections.deque()
q.append(i)
while q:
t = q.pop()
f[t] = True
for g in a[t]:
if not f[g]:
q.append(g)
print(res)
main()
| import sys
sys.setrecursionlimit(10**7)
n,m = list(map(int,input().split()))
f = [False for _ in range(n)]
a = [[] for _ in range(n)]
res = 0
def dfs(k):
f[k] = True
for g in a[k]:
if not f[g]:
dfs(g)
for _ in range(m):
x,y,z = list(map(int,input().split()))
a[x-1].append(y-1)
a[y-1].append(x-1)
for i in range(n):
if not f[i]:
res += 1
dfs(i)
print(res)
| p03045 |
import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b,c = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(v):
if len(edge[v])==0:
return 0
for u in edge[v]:
if visited[u]==False:
visited[u]=True
dfs(u)
return 0
ans = 0
visited = [False]*N
for i in range(N):
if visited[i]==False:
visited[i]=True
dfs(i)
ans += 1
print(ans) | N, M = list(map(int, input().split()))
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 roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
uf = UnionFind(N)
for _ in range(M):
x,y,z = list(map(int, input().split()))
uf.union(x-1,y-1)
ans = len(uf.roots())
print(ans)
| p03045 |
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b,c = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
from collections import deque
ans = 0
visited = [False]*N
d = deque()
for i in range(N):
if visited[i]==False:
visited[i]=True
d.append(i)
while len(d)>0:
v = d.popleft()
for w in edge[v]:
if visited[w]==False:
visited[w]=True
d.append(w)
ans += 1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def num_roots(self):
return len([i for i, x in enumerate(self.parents) if x < 0])
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def num_members(self,x):
return abs(self.parents[self.find(x)])
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for i in range(M):
a,b,c = list(map(int, input().split()))
uf.union(a-1,b-1)
print((uf.num_roots())) | p03045 |
n, m = list(map(int, input().split()))
card = [[] for _ in range(n)]
for _ in range(m):
x, y, _ = list(map(int, input().split()))
card[x-1].append(y-1)
card[y-1].append(x-1)
checked = [False] * n
count = 0
import queue
q = queue.Queue()
for i in range(n):
if checked[i]:
continue
count += 1
q.put(i)
while not q.empty():
j = q.get()
checked[j] = True
for k in card[j]:
if not checked[k]:
q.put(k)
print (count)
| n, m = list(map(int, input().split()))
card = [[] for _ in range(n)]
for _ in range(m):
x, y, _ = list(map(int, input().split()))
card[x-1].append(y-1)
card[y-1].append(x-1)
checked = [False] * n
count = 0
from collections import deque
for i in range(n):
if checked[i]:
continue
count += 1
q = deque([i])
while q:
j = q.popleft()
checked[j] = True
for k in card[j]:
if not checked[k]:
q.append(k)
print (count)
| p03045 |
n, m = list(map(int, input().split()))
card = [[] for _ in range(n)]
for _ in range(m):
x, y, _ = list(map(int, input().split()))
card[x-1].append(y-1)
card[y-1].append(x-1)
checked = [False] * n
count = 0
from collections import deque
for i in range(n):
if checked[i]:
continue
count += 1
q = deque([i])
while q:
j = q.popleft()
checked[j] = True
for k in card[j]:
if not checked[k]:
q.append(k)
print (count)
| n, m = list(map(int, input().split()))
card = [[] for _ in range(n)]
for _ in range(m):
x, y, _ = list(map(int, input().split()))
card[x-1].append(y-1)
card[y-1].append(x-1)
checked = [False] * n
count = 0
for i in range(n):
if checked[i]:
continue
count += 1
q = [i]
while q:
j = q.pop()
checked[j] = True
for k in card[j]:
if not checked[k]:
q.append(k)
print (count) | p03045 |
import sys
sys.setrecursionlimit(10**6)
n,m = list(map(int,input().split()))
global clasta
clasta = [-1 for i in range(n)]
path = [[] for i in range(n)]
used = [0 for i in range(n)]
for _ in range(m):
x,y,z = list(map(int,input().split()))
path[x-1].append(y-1)
path[y-1].append(x-1)
def dfs(now,color):
for y in path[now]:
if clasta[y] == -1:
clasta[y] = color
dfs(y,color)
ans = 0
for idx,i in enumerate(clasta):
if i == -1:
clasta[idx] = idx
if path[idx]:
dfs(idx,idx)
ans += 1
print(ans) | import sys
sys.setrecursionlimit(10**6)
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 size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m = list(map(int,input().split()))
uf = UnionFind(n)
for _ in range(m):
x,y,z = list(map(int,input().split()))
uf.union(x-1, y-1)
print((uf.group_count())) | p03045 |
# -*- coding:utf-8 -*-
class UnionFindVerSize():
def __init__(self, N):
""" N個のノードのUnion-Find木を作成する """
# 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる
self._parent = [n for n in range(0, N)]
# グループのサイズ（個数）
self._size = [1] * N
def find_root(self, x):
""" xの木の根(xがどのグループか)を求める """
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x]) # 縮約
return self._parent[x]
def unite(self, x, y):
""" xとyの属する集合を併合する """
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
# 小さい方を大きい方に併合させる（木の偏りが減るので）
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
""" xが属するグループのサイズ（個数）を返す """
return self._size(self.find_root(x))
def is_same_group(self, x, y):
""" xとyが同じ集合に属するか否か """
return self.find_root(x) == self.find_root(y)
def solve():
"""戦略
□ □ □ □ □ □ □ □ □ □ □ □ □ □ □
|_| |_| |_| |_| | |_|_|_|
|___|
1 2 3 4 5 6 7
上みたいなものを考えたらわかるが、答えはグループの数(=7)。
Union-Findを使えばよい。
"""
N, M = list(map(int, input().split()))
X, Y, Z = [], [], []
uf = UnionFindVerSize(N)
for i in range(M):
x, y, z = list(map(int, input().split()))
x, y = x-1, y-1
uf.unite(x, y)
# 答えは、(グループの数)
ans = 0
for i in range(N):
if uf.find_root(i) == i:
ans += 1
print(ans)
if __name__ == "__main__":
solve()
| # -*- coding:utf-8 -*-
class UnionFindVerDepth():
def __init__(self, N):
""" N個のノードのUnion-Find木を作成する """
# 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる
self._parent = [n for n in range(0, N)]
# グループの深さ
self._depth = [1] * N
def find_root(self, x):
""" xの木の根(xがどのグループか)を求める """
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x]) # 縮約
return self._parent[x]
def unite(self, x, y):
""" xとyの属する集合を併合する """
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
# 小さい方を大きい方に併合させる（木の偏りが減るので）
if self._depth[gx] < self._depth[gy]:
self._parent[gx] = gy
else:
self._parent[gy] = gx
if self._depth[gx] == self._depth[gy]: self._depth[gx] += 1
def get_depth(self, x):
""" xが属するグループの深さを返す """
return self._depth(self.find_root(x))
def is_same_group(self, x, y):
""" xとyが同じ集合に属するか否か """
return self.find_root(x) == self.find_root(y)
def solve():
"""戦略
□ □ □ □ □ □ □ □ □ □ □ □ □ □ □
|_| |_| |_| |_| | |_|_|_|
|___|
1 2 3 4 5 6 7
上みたいなものを考えたらわかるが、答えはグループの数(=7)。
Union-Findを使えばよい。
"""
N, M = list(map(int, input().split()))
X, Y, Z = [], [], []
uf = UnionFindVerDepth(N)
for i in range(M):
x, y, z = list(map(int, input().split()))
x, y = x-1, y-1
uf.unite(x, y)
# 答えは、(グループの数)
ans = 0
for i in range(N):
if uf.find_root(i) == i:
ans += 1
print(ans)
if __name__ == "__main__":
solve()
| p03045 |
import sys
sys.setrecursionlimit(10**5)
n, m = list(map(int, input().split()))
adjacent_list = [[] for i in range(n + 1)]
for i in range(m):
x, y, z = list(map(int,input().split()))
adjacent_list[x].append(y)
adjacent_list[y].append(x)
##結局、グラフが何個あるか数える
finished = set()
ans = 0
def dfs(node):
global finished
finished.add(node)
for i in adjacent_list[node]:
if i not in finished:
dfs(i)
while len(finished) != n:
for i in range(1,n+1):
if i not in finished:
dfs(i)
ans += 1
print(ans)
| import sys
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
adjacent_list = [[] for i in range(n + 1)]
for i in range(m):
x, y, z = list(map(int,input().split()))
adjacent_list[x].append(y)
adjacent_list[y].append(x)
##結局、グラフが何個あるか数える
finished = set()
ans = 0
def dfs(node):
global finished
finished.add(node)
for i in adjacent_list[node]:
if i not in finished:
dfs(i)
while len(finished) != n:
for i in range(1,n+1):
if i not in finished:
dfs(i)
ans += 1
print(ans)
| p03045 |
import collections
class UnionFind:
def __init__(self, max_size):
self.parent = [i for i in range(max_size+1)]
self.depth = [0 for _ in range(max_size+1)]
self.cnt = [1 for i in range(max_size+1)]
# 菲再起にしたい Whileでスタックに突っこみながら見てスタックの中身全部に代入
'''
# 実はこっちのほうが速かったなんで？
def find(self, x):
t = x
while t!=self.parent[t]:
t = self.parent[t]
self.parent[x]=t
return t
'''
def find(self, x):
de = collections.deque()
t = x
while t != self.parent[t]:
de.append(t)
t = self.parent[t]
while de:
tmp = de.pop()
self.parent[tmp] = t
return t
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.depth[x] < self.depth[y]:
self.parent[x] = y
self.cnt[y] += self.cnt[x]
else:
self.parent[y] = x
self.cnt[x] += self.cnt[y]
if self.depth[x] == self.depth[y]:
self.depth[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.cnt[self.find(x)]
n, m = list(map(int, input().split()))
utree = UnionFind(n+10)
for _ in range(m):
x, y, z = list(map(int, input().split()))
utree.unite(x, y)
s = {utree.find(i) for i in range(1, n+1)}
print((len(s)))
| import collections
class UnionFind:
def __init__(self, max_size):
self.parent = [i for i in range(max_size+1)]
self.depth = [0 for _ in range(max_size+1)]
self.cnt = [1 for i in range(max_size+1)]
def find(self, x):
deque = collections.deque()
t = x
while t != self.parent[t]:
deque.append(t)
t = self.parent[t]
while deque:
tmp = deque.pop()
self.parent[tmp] = t
return t
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.depth[x] < self.depth[y]:
self.parent[x] = y
self.cnt[y] += self.cnt[x]
else:
self.parent[y] = x
self.cnt[x] += self.cnt[y]
if self.depth[x] == self.depth[y]:
self.depth[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.cnt[self.find(x)]
n, m = list(map(int, input().split()))
utree = UnionFind(n+10)
for _ in range(m):
x, y, z = list(map(int, input().split()))
utree.unite(x, y)
s = {utree.find(i) for i in range(1, n+1)}
print((len(s))) | p03045 |
import sys
from collections import deque
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
memo = set(list(range(n)))
E = [[] for i in range(n)]
for i in range(m):
x, y, z = list(map(int, input().split()))
E[x-1].append(y-1)
E[y-1].append(x-1)
def dfs(cur, pre):
stack = deque([[cur, pre]])
while stack:
cur, pre = stack.pop()
if pre != -1:
memo.discard(cur)
for e in E[cur]:
if e != pre and e in memo:
stack.append([e, cur])
ans = 0
while len(memo):
cur = memo.pop()
dfs(cur, -1)
ans += 1
print(ans)
| import sys
from collections import deque
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
memo = set(list(range(n)))
E = [[] for i in range(n)]
for i in range(m):
x, y, z = list(map(int, input().split()))
E[x-1].append(y-1)
E[y-1].append(x-1)
def dfs(cur, pre):
stack = deque([[cur, pre]])
while stack:
cur, pre = stack.pop()
memo.discard(cur)
for e in E[cur]:
if e != pre and e in memo:
stack.append([e, cur])
ans = 0
for i in range(n):
if i in memo:
dfs(i, -1)
ans += 1
print(ans)
| p03045 |
import sys
from collections import deque
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
memo = set(list(range(n)))
E = [[] for i in range(n)]
for i in range(m):
x, y, z = list(map(int, input().split()))
E[x-1].append(y-1)
E[y-1].append(x-1)
def dfs(cur, pre):
stack = deque([[cur, pre]])
while stack:
cur, pre = stack.pop()
memo.discard(cur)
for e in E[cur]:
if e != pre and e in memo:
stack.append([e, cur])
ans = 0
for i in range(n):
if i in memo:
dfs(i, -1)
ans += 1
print(ans)
| import sys
from collections import deque
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
memo = [1 for _ in range(n)]
E = [[] for _ in range(n)]
for i in range(m):
x, y, z = list(map(int, input().split()))
E[x-1].append(y-1)
E[y-1].append(x-1)
def dfs(cur, pre):
stack = deque([[cur, pre]])
while stack:
cur, pre = stack.pop()
memo[cur] = 0
for e in E[cur]:
if e != pre and memo[e]:
stack.append([e, cur])
ans = 0
for i in range(n):
if memo[i]:
dfs(i, -1)
ans += 1
print(ans)
| p03045 |
def search(n):
while A[n-1] != n:
n = A[n-1]
return n
N, M = list(map(int, input().split()))
A = [i for i in range(1, N+1)]
ans = 0
for i in range(M):
X, Y, Z = list(map(int, input().split()))
X_root, Y_root = search(X), search(Y)
if X_root != Y_root:
A[X_root-1] = Y_root
ans += 1
print((N-ans)) | def search(n):
idx = n
while A[n-1] != n:
n = A[n-1]
A[idx-1] = n
return n
N, M = list(map(int, input().split()))
A = [i for i in range(1, N+1)]
ans = 0
for i in range(M):
X, Y, Z = list(map(int, input().split()))
X_root, Y_root = search(X), search(Y)
if X_root != Y_root:
A[X_root-1] = Y_root
ans += 1
print((N-ans)) | p03045 |
r=lambda x:x if u[x]<0else r(u[x])
n,m,*t=list(map(int,open(0).read().split()))
u=[-1]*-~n
for x,y in zip(t[::3],t[1::3]):
x,y=sorted((r(x),r(y)))
if x!=y:u[x]+=u[y];u[y]=x
print((sum(i<0for i in u)-1)) | r=lambda x:x*(u[x]<0)or r(u[x])
n,m,*t=list(map(int,open(0).read().split()))
u=[-1]*-~n
for x,y in zip(t[::3],t[1::3]):
x,y=sorted((r(x),r(y)))
if x!=y:u[x]+=u[y];u[y]=x
print((sum(i<0for i in u)-1)) | p03045 |
# --*-coding:utf-8-*--
def dsMakeSet(ds, x):
ds[x] = x
def dsFind(ds, x):
if ds[x] == x:
return x
while ds[x] != x:
x = ds[x]
ds[x] = x
return x
def dsUnion(ds, x, y):
xRoot = dsFind(ds, x)
yRoot = dsFind(ds, y)
if xRoot != yRoot:
ds[yRoot] = xRoot
return True
return False
def main():
N, M = list(map(int, input().split()))
ds = {}
for i in range(N):
dsMakeSet(ds, i+1)
n = 0
for i in range(M):
X,Y,Z = list(map(int, input().split()))
if dsUnion(ds, X, Y):
n += 1
print((N - n))
if __name__ == '__main__':
main()
| # --*-coding:utf-8-*--
def dsMakeSet(ds, x):
ds[x] = x
def dsFind(ds, x):
if ds[x] == x:
return x
x0 = x
while ds[x] != x:
x = ds[x]
ds[x0] = x
return x
def dsUnion(ds, x, y):
xRoot = dsFind(ds, x)
yRoot = dsFind(ds, y)
if xRoot != yRoot:
ds[yRoot] = xRoot
return True
return False
def main():
N, M = list(map(int, input().split()))
ds = {}
for i in range(N):
dsMakeSet(ds, i+1)
n = 0
for i in range(M):
X,Y,Z = list(map(int, input().split()))
if dsUnion(ds, X, Y):
n += 1
print((N - n))
if __name__ == '__main__':
main()
| p03045 |
import sys
sys.setrecursionlimit(10 ** 5)
class UniteFind:
def __init__(self, N):
self.par = [i for i in range(N)]
def root(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
self.par[ry] = rx
def same(self, x, y):
if (self.root(x) == self.root(y)):
return True
return False
N, M = list(map(int, input().split()))
rf = UniteFind(N)
for _ in range(M):
x, y, _ = list(map(int, input().split()))
rf.unite(x-1, y-1)
m = {i: -1 for i in range(N)}
ans = 0
for i in range(N):
if m[rf.root(i)] == -1:
m[rf.root(i)] = 1
ans += 1
print(ans)
| import sys
sys.setrecursionlimit(10 ** 5)
input = sys.stdin.readline
N, M = list(map(int, input().split()))
ans = list(range(N))
def root(a):
if a==ans[a]:
return a
else:
ans[a] = root(ans[a])
return ans[a]
for _ in range(M):
x, y, _ = [int(a)-1 for a in input().split()]
rx, ry = root(x), root(y)
if rx != ry:
ans[ry] = rx
count = 0
for i,a in enumerate(ans):
count += i==a
print(count)
| p03045 |
import sys
input = sys.stdin.readline
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)
#'''
N, M = list(map(int,input().split()))
q = []
c = [0] * N
A = [[] for i in range(N)]
for i in range(M):
x, y, z = list(map(int,input().split()))
x = x - 1
y = y - 1
A[x].append(y)
A[y].append(x)
cost = 0
for i in range(N):
if c[i] == 0:
cost += 1
q.append(i)
for _ in range(N):
if len(q) == 0:
break
j = q.pop()
c[j] = 1
for k in A[j]:
if c[k] == 0:
q.append(k)
print(cost)
| import sys
input = sys.stdin.readline
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)
#'''
N, M = list(map(int,input().split()))
q = []
c = [0] * N
A = [[] for i in range(N)]
for i in range(M):
x, y, z = list(map(int,input().split()))
x = x - 1
y = y - 1
A[x].append(y)
A[y].append(x)
cost = 0
for i in range(N):
if c[i] == 0:
cost += 1
q.append(i)
while len(q):
j = q.pop()
c[j] = 1
for k in A[j]:
if c[k] == 0:
q.append(k)
print(cost)
| p03045 |
# input = sys.stdin.readline
from bisect import *
from collections import *
from heapq import *
# import functools
# import itertools
# import math
N,M=list(map(int,input().split()))
XYZ=[list(map(int,input().split())) for i in range(M)]
data=[[] for i in range(N+1)]
ittenai=[]
for x,y,z in XYZ:
data[x].append(y)
data[y].append(x)
ittenai.append(x)
ittenai.append(y)
ittenai=set(ittenai)
count=N-len(ittenai)
while ittenai:
x=list(ittenai)[0]
stack=deque([x])
ittenai.remove(x)
count+=1
while stack:
num=stack.popleft()
for i in data[num]:
if i in ittenai:
ittenai.remove(i)
stack.append(i)
print(count)
| # input = sys.stdin.readline
from bisect import *
from collections import *
from heapq import *
# import functools
# import itertools
# import math
N,M=list(map(int,input().split()))
XYZ=[list(map(int,input().split())) for i in range(M)]
data=[[] for i in range(N+1)]
ittenai=[]
for x,y,z in XYZ:
data[x].append(y)
data[y].append(x)
ittenai.append(x)
ittenai.append(y)
ittenai=set(ittenai)
count=N-len(ittenai)
while ittenai:
x=ittenai.pop()
stack=deque([x])
count+=1
while stack:
num=stack.popleft()
for i in data[num]:
if i in ittenai:
ittenai.remove(i)
stack.append(i)
print(count)
| p03045 |
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)
n,m=list(map(int,input().split()))
uni = UnionFind(n-1)
for i in range(m):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
uni.union(a,b)
t = set([])
for i in range(n):
p = uni.find(i)
t.add(p)
print((len(t))) | def main():
#Union Find
#locate x
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
#merge x y
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
#x and y in same group
def same(x,y):
return find(x) == find(y)
#number of factor of x group
def size(x):
return -par[find(x)]
n,m = list(map(int,input().split()))
#initiarize
#根なら-size,子なら親の頂点
par = [-1]*n
for i in range(m):
X,Y,Z = list(map(int,input().split()))
unite(X-1,Y-1)
tank = set([])
for i in range(n):
tank.add(find(i))
print((len(tank)))
if __name__ == '__main__':
main() | p03045 |
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
n,m = list(map(int,input().split()))
par = [-1]*n
for i in range(m):
X,Y,Z = list(map(int,input().split()))
unite(X-1,Y-1)
tank = set([])
for i in range(n):
tank.add(find(i))
print((len(tank)))
| n,m = list(map(int,input().split()))
par = [-1]*(n)
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def same(x,y):
return find(x) == find(y)
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
else:
if par[x] > par[y]:x,y = y,x
par[x] += par[y]
par[y] = x
def size(x):
return -par[find(x)]
for i in range(m):
x,y,z = list(map(int,input().split()))
unite(x-1,y-1)
ans = 0
# print(par)
for i in range(n):
if par[i] <0:
ans += 1
print(ans) | p03045 |
from collections import deque
N,M = list(map(int,input().split()))
node_list = [[] for i in range(N)]
for i in range(M):
x,y,z=list(map(int,input().split()))
node_list[x-1].append(y-1)
node_list[y-1].append(x-1)
checked_list = [-1 for i in range(N)]
def BFS(start,color,checked_list,node_list):
Q=deque([start])
checked_list[start]=color
while len(Q)>0:
v1 = Q.pop()
for v2 in node_list[v1]:
if checked_list[v2]==-1:
checked_list[v2]=color
Q.appendleft(v2)
count = 0
for i in range(N):
if checked_list[i]==-1:
BFS(i,count,checked_list,node_list)
count+=1
print(count) | import sys
def input():
return sys.stdin.readline()[:-1]
N,M = list(map(int,input().split()))
e_list = [[] for i in range(N)]
for i in range(M):
x,y,z = list(map(int,input().split()))
x,y = x-1,y-1
e_list[x].append(y)
e_list[y].append(x)
from collections import deque
def BFS(vi,color,color_list):
Q = deque([vi])
color_list[vi]=color
while len(Q)>0:
v = Q.pop()
for v1 in e_list[v]:
if color_list[v1]==-1:
color_list[v1]=color
Q.appendleft(v1)
color_list = [-1]*N
color = 0
for i in range(N):
if color_list[i]==-1:
BFS(i,color,color_list)
color+=1
print(color) | p03045 |
N, M = list(map(int, input().split()))
XYZ = [list(map(int, input().split())) for _ in range(M)]
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 size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(N)
for xyz in XYZ:
x, y, z = xyz
uf.union(x - 1, y - 1)
print((uf.group_count()))
| 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 size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n, m = list(map(int, input().split()))
XYZ = [list(map(int, input().split())) for _ in range(m)]
uf = uf = UnionFind(n)
for x, y, z in XYZ:
x -= 1
y -= 1
uf.union(x, y)
print((uf.group_count())) | p03045 |
n,m=list(map(int,input().split()))
import sys
sys.setrecursionlimit(10**9) #再帰の上限をあげる
root=[-1 for i in range(n+1)] #自分が親ならグループの人数のマイナス倍を、そうでないなら（元）親の番号を示す
def r(x): #親は誰？
if root[x]<0:
return x
else:
root[x]=r(root[x])
return root[x]
def unite(x,y):
x=r(x)
y=r(y)
if x==y:
return
if root[x]<root[y]:
x,y=y,x
root[x]+=root[y]
root[y]=x
for i in range(m):
x,y,z=list(map(int,input().split()))
unite(x,y)
g=[0]*(n+1)
for i in range(1,n+1):
g[r(i)]+=1
ans=0
for i in range(n+1):
if g[i]>0:
ans+=1
print(ans)
| n,m=list(map(int,input().split()))
import sys
sys.setrecursionlimit(10**9) #再帰の上限をあげる
root=[-1 for i in range(n+1)] #自分が親ならグループの人数のマイナス倍を、そうでないなら（元）親の番号を示す
def r(x): #親は誰？
if root[x]<0:
return x
else:
return r(root[x])
def unite(x,y):
x=r(x)
y=r(y)
if x==y:
return
if root[x]>root[y]:
x,y=y,x
root[x]+=root[y]
root[y]=x
for i in range(m):
x,y,z=list(map(int,input().split()))
unite(x,y)
g=[0]*(n+1)
for i in range(1,n+1):
g[r(i)]+=1
ans=0
for i in range(n+1):
if g[i]>0:
ans+=1
print(ans)
| p03045 |
import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
num_edges = M
edges = [list(map(int, input().split())) for i in range(num_edges)]
adj = [[] for i in range(N+1)]
for ed in edges:
adj[ed[0]] += [[ed[1], ed[2]]]
adj[ed[1]] += [[ed[0], ed[2]]]
col_list = [-1 for i in range(N+1)]
def recfun(v, col):
col_list[v] = col #色を更新
for ed in adj[v]: #隣接する頂点をみる
if col_list[ed[0]] == -1: #更新していない場合
recfun(ed[0], col) #同じ色でその先をみる
count = 0
for i in range(1, N+1):
if col_list[i] == -1:
count +=1
recfun(i, count)
print(count) | class UnionFind():
def __init__(self,size):
self.table=[-1]*size
def root(self,x):
while self.table[x]>=0:
x=self.table[x]
return x
def unite(self,x,y):
s1=self.root(x)
s2=self.root(y)
if s1!=s2:
if self.table[s1]>self.table[s2]:
s1,s2=s2,s1
self.table[s1]+=self.table[s2]
self.table[s2]=s1
return
def same(self,x,y):
return self.root(x)==self.root(y)
def size(self,x):
return -self.table[self.root(x)]
#####
N, M = list(map(int, input().split()))
uf = UnionFind(N+1)
for i in range(M):
ui, vi, wi = list(map(int, input().split()))
uf.unite(ui, vi)
print((sum([t < 0 for t in uf.table[1:]]))) | p03045 |
import sys
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
t = [[] for i in range(n)]
c = [-1 for i in range(n)]
for i in range(m):
x, y ,z = list(map(int, input().split()))
x -= 1
y -= 1
t[x].append(y)
t[y].append(x)
def dfs(num, depth):
if c[num] != -1:
return
else:
c[num] = depth
for i in t[num]:
dfs(i, depth)
cnt = 0
for i in range(n):
if c[i] == -1:
cnt += 1
dfs(i, cnt)
print((max(c)))
| import sys
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
t = [[] for i in range(n)]
c = [-1 for i in range(n)]
for line in sys.stdin:
x, y ,z = list(map(int, line.split()))
x -= 1
y -= 1
t[x].append(y)
t[y].append(x)
def dfs(num, depth):
if c[num] != -1:
return
else:
c[num] = depth
for i in t[num]:
dfs(i, depth)
cnt = 0
for i in range(n):
if c[i] == -1:
cnt += 1
dfs(i, cnt)
print(cnt)
| p03045 |
import sys
from collections import deque, defaultdict
import copy
import bisect
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
import math
N, M = list(map(int, input().split()))
XYZ = []
for i in range(M):
XYZ.append(list(map(int, input().split())))
renketu = [dict() for i in range(N)]
for i in range(N):
renketu[i]["iro"] = -1
renketu[i]["eda"] = []
for i in range(M):
renketu[XYZ[i][0] - 1]["eda"].append([XYZ[i][0], XYZ[i][1]])
renketu[XYZ[i][1] - 1]["eda"].append([XYZ[i][1], XYZ[i][0]])
num = 0
for i in range(N):
if renketu[i]['iro'] == -1:
num += 1
stack = [i]
# print(rest, num)
renketu[i]['iro'] = num
while len(stack) > 0:
node = stack.pop()
for edge in renketu[node]["eda"]:
if renketu[edge[1] - 1]["iro"] == -1:
renketu[edge[1] - 1]["iro"] = num
stack.append(edge[1] - 1)
print(num) |
import sys
def input():
return sys.stdin.readline().strip()
N, M = list(map(int, input().split()))
class Union_Find():
def __init__(self, n):
self.union = [i for i in range(n)]
self.level = [0 for i in range(n)]
self.num = n
def root(self, i, mode=0):
keiro = [i]
ans = i
while ans != self.union[ans]:
ans = self.union[ans]
keiro.append(ans)
if mode == 0:
return ans
else:
return ans, keiro
def unite(self, i, j):
root_i, list_i = self.root(i, 1)
root_j, list_j = self.root(j, 1)
if root_i != root_j:
self.num -= 1
if self.level[root_i] < self.level[root_j]:
self.level[root_j] = max(self.level[root_i] + 1, self.level[root_j])
for node in list_i:
self.union[node] = root_j
else:
self.level[root_i] = max(self.level[root_j] + 1, self.level[root_i])
for node in list_j:
self.union[node] = root_i
union = Union_Find(N)
for i in range(M):
X, Y, Z = list(map(int, input().split()))
union.unite(X - 1, Y - 1)
print((union.num)) | p03045 |
N,M=list(map(int, input().split()))
E=[[] for _ in range(N)]
for _ in range(M):
x,y,z=[int(i)-1 for i in input().split()]
E[x].append(y)
E[y].append(x)
#情報のつながりがあるカードでグルーピングする
#グループIDのリスト(0は未割り当て)
G=[0]*(N+1)
def dfs(root,g):
stack=[root]
G[root]=g
while stack:
node=stack.pop()
for to in E[node]:
if G[to]==0:
G[to]=g
stack.append(to)
ans=0
for i in range(N):
if G[i]==0:
ans+=1
dfs(i,ans)
print(ans)
| import sys
def main():
input = sys.stdin.readline
N,M=list(map(int, input().split()))
uf = UnionFindTree(N)
for _ in range(M):
x,y,z=list(map(int, input().split()))
uf.union(x-1,y-1)
c=set([uf.find(i) for i in range(N)])
print((len(c)))
class UnionFindTree:
def __init__(self, n):
self.parent = [-1] * n
def find(self, x):
p = self.parent
while p[x] >= 0: x, p[x] = p[x], p[p[x]]
return x
def union(self, x, y):
x, y, p = self.find(x), self.find(y), self.parent
if x == y: return
if p[x] > p[y]: x, y = y, x
p[x], p[y] = p[x] + p[y], x
def same(self, x, y): return self.find(x) == self.find(y)
def size(self, x): return -self.parent[self.find(x)]
if __name__ == '__main__':
main() | p03045 |
# coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]: #xの要素数がyの要素数より「小さい」とき入れ替える
x,y=y,x
self.size[x] += self.size[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return self.size[self.root(x)]
n,m = [int(i) for i in input().split()]
T=UnionFind(n)
c=0
for _ in [0]*m:
x,y,z=[int(i) for i in input().split()]
if not T.issame(x-1,y-1):
T.merge(x-1,y-1)
c+=1
print((n-c)) | # coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]:
self.size[y] += self.size[x] #yの要素数を更新
self.parent[x] = y #xをyにつなぐ
else:
self.size[x] += self.size[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return self.size[self.root(x)]
n,m = [int(i) for i in input().split()]
T=UnionFind(n)
c=0
for _ in [0]*m:
x,y,z=[int(i) for i in input().split()]
if not T.issame(x-1,y-1):
T.merge(x-1,y-1)
c+=1
print((n-c)) | p03045 |
# coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]:
self.size[y] += self.size[x] #yの要素数を更新
self.parent[x] = y #xをyにつなぐ
else:
self.size[x] += self.size[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return self.size[self.root(x)]
n,m = [int(i) for i in input().split()]
T=UnionFind(n)
c=0
for _ in [0]*m:
x,y,z=[int(i) for i in input().split()]
if not T.issame(x-1,y-1):
T.merge(x-1,y-1)
c+=1
print((n-c)) | # coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]:
self.size[y] += self.size[x] #yの要素数を更新
self.parent[x] = y #xをyにつなぐ
else:
self.size[x] += self.size[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return self.size[self.root(x)]
n,m = [int(i) for i in input().split()]
T=UnionFind(n)
c=0
for _ in [0]*m:
x,y,z=[int(i) for i in input().split()]
if T.merge(x-1,y-1):
c+=1
print((n-c)) | p03045 |
# coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))#親ノード
self.size = [1]*n #グループの要素数
def root(self, x): #root(x): xの根ノードを返す．
while self.parent[x] != x:
self.parent[x] = self.parent[self.parent[x]]
x = self.parent[x]
return x
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.size[x] < self.size[y]:
self.size[y] += self.size[x] #yの要素数を更新
self.parent[x] = y #xをyにつなぐ
else:
self.size[x] += self.size[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return self.size[self.root(x)]
n,m = [int(i) for i in input().split()]
T=UnionFind(n)
c=0
for _ in [0]*m:
x,y,z=[int(i) for i in input().split()]
if T.merge(x-1,y-1):
c+=1
print((n-c)) | class UnionFind:
def __init__(self, size):
self.parent = [-1]*size #非負なら親ノード，負ならグループの要素数
def root(self, x): #root(x): xの根ノードを返す．
if self.parent[x] < 0:
return x
elif self.parent[self.parent[x]] < 0:
return self.parent[x]
else:
self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
return self.parent[x]
def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.parent[x] > self.parent[y]: #xの要素数がyの要素数より「小さい」とき入れ替える
x,y=y,x
self.parent[x] += self.parent[y] #xの要素数を更新
self.parent[y] = x #yをxにつなぐ
return True
def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
return self.root(x) == self.root(y)
def size(self,x): #size(x): xのいるグループの要素数を返す
return -self.parent[self.root(x)]
n,m = [int(i) for i in input().split()]
T=UnionFind(n)
c=0
for _ in [0]*m:
x,y,z=[int(i) for i in input().split()]
if T.merge(x-1,y-1):
c+=1
print((n-c))
| p03045 |
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)
N,M=list(map(int,input().split()))
a=UnionFind(N)
for i in range(M):
X,Y,Z=list(map(int,input().split()))
if a.same_check(X,Y):
pass
else:
a.union(X,Y)
answer=set()
for i in range(1,N+1):
answer.add(a.find(i))
print((len(answer)))
| class UnionFind:
def __init__(self, n):
self.par = [-1]*(n+1)
self.sizes=[1]*(n+1)
# 検索
def find(self, x):
if self.par[x]<0:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
d1=self.par[x]
d2=self.par[y]
if d1<=d2:
self.par[y]=x
self.sizes[x]=self.sizes[x]+self.sizes[y]
if d1==d2:
self.par[x]=self.par[x]-1
else:
self.par[x]=y
self.sizes[y]=self.sizes[x]+self.sizes[y]
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
#サイズ
def size(self,x):
return self.sizes[find(x)]
#木の数
def number(self):
count=0
for i in self.par[1:]:
if i<0:
count=count+1
return count
N,M=list(map(int,input().split()))
U=UnionFind(N)
for i in range(M):
X,Y,Z=list(map(int,input().split()))
U.union(X,Y)
print((U.number()))
| p03045 |
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
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
x, y, z = list(map(int, input().split()))
uf.merge(x - 1, y - 1)
res = set()
for i in range(n):
res.add(uf.get_root(i))
print((len(res))) | import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n))
self.ranks = [0 for _ in range(n)]
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
n, m = ril()
uf = UnionFind(n)
for _ in range(m):
x, y, z = ril()
uf.merge(x - 1, y - 1)
res = set()
for i in range(n):
res.add(uf.get_root(i))
print((len(res))) | p03045 |
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n))
self.ranks = [0 for _ in range(n)]
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
n, m = ril()
uf = UnionFind(n)
for _ in range(m):
x, y, z = ril()
uf.merge(x - 1, y - 1)
res = set()
for i in range(n):
res.add(uf.get_root(i))
print((len(res))) | import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = list(range(n))
self.ranks = [0 for _ in range(n)]
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
n, m = ril()
uf = UnionFind(n)
for _ in range(m):
x, y, z = ril()
uf.merge(x - 1, y - 1)
for i in range(n):
uf.get_root(i)
print((len(set(uf.parents)))) | p03045 |
def dfs(g, start):
global visit
visiting = [start]
while visiting:
v = visiting.pop()
visit[v] = True
for v2 in g.get(v,()):
if v2 in visit or v2 in visiting:
continue
visiting.append(v2)
N,M = list(map(int, input().split()))
visit = {}
g = {}
for v in range(1,N+1):
g[v] = []
for _ in range(M):
x,y,z = list(map(int, input().split()))
g[x].append(y)
g[y].append(x)
count = 0
for v in range(1,N+1):
if v in visit:
continue
dfs(g,v)
count += 1
print(count)
| N, M = list(map(int, input().split()))
graph = [[] for i in range(N)]
for i in range(M):
x, y, z = list(map(int, input().split()))
x, y = x-1, y-1
graph[x].append(y)
graph[y].append(x)
visited = [False for i in range(N)]
def dfs(v):
Q = []
visited[v] = True
Q.append(v)
while len(Q) > 0:
v = Q.pop()
for u in graph[v]:
if not visited[u]:
visited[u] = True
Q.append(u)
count = 0
for i in range(N):
if not visited[i]:
dfs(i)
count += 1
print(count)
| p03045 |
import sys
sys.setrecursionlimit(1000000)
N,M = list(map(int,input().split()))
XYZ = [list(map(int,input().split())) for _ in range(M)]
G = [[] for _ in range(N)]
for i in XYZ:
G[i[0]-1].append(i[1])
G[i[1]-1].append(i[0])
check = [False for _ in range(N)]
def DFS(G,s):
check[s-1] = True
for i in G[s-1]:
if not check[i-1]:
DFS(G,i)
ans = 0
for i in range(N):
if not check[i]:
DFS(G,i+1)
ans += 1
print(ans)
| import sys
sys.setrecursionlimit(1000000)
N, M = list(map(int, input().split()))
X = [0] * M
Y = [0] * M
Z = [0] * M
for i in range(M):
X[i], Y[i], Z[i] = list(map(int, input().split()))
reach = [[] for _ in range(N)]
for i in range(M) :
reach[Y[i]-1].append(X[i])
reach[X[i]-1].append(Y[i])
approach = [False for _ in range(N)]
def change(reach, s):
approach[s-1] = True
for i in reach[s-1]:
if not approach[i-1] :
change(reach, i)
ans = 0
for i in range(N) :
if not approach[i]:
change(reach, i+1)
ans += 1
print(ans) | p03045 |
import sys
sys.setrecursionlimit(10**7)
def update(v):
for nv in con[v]:
if seen[nv]:
continue
seen[nv]=1
update(nv)
N,M=list(map(int,input().split()))
seen=[0]*N
con=[[] for i in range(N)]
cnt=[[i,0] for i in range(N)]
for i in range(M):
X,Y,Z=list(map(int,input().split()))
X,Y=X-1,Y-1
con[X].append(Y)
con[Y].append(X)
cnt[X][1]+=1
cnt[Y][1]+=1
cnt.sort(key=lambda x:x[1],reverse=True)
ans=0
for i,a in cnt:
if(seen[i]):
continue
ans+=1
seen[i]=1
update(i)
print(ans) | import sys
sys.setrecursionlimit(10**7)
def update(v):
for nv in G[v]:
if seen[nv]:
continue
seen[nv]=1
update(nv)
N,M=list(map(int,input().split()))
seen=[0]*N
G=[[] for i in range(N)]
for i in range(M):
X,Y,Z=list(map(int,input().split()))
X,Y=X-1,Y-1
G[X].append(Y)
G[Y].append(X)
ans=0
for i in range(N):
if(seen[i]):
continue
ans+=1
seen[i]=1
update(i)
print(ans) | p03045 |
n,m=list(map(int,input().split()))
parent=[i for i in range(n)]
rank=[0 for i in range(n)]
def find(a):
if parent[a]==a:
return a
else:
return find(parent[a])
def union(a,b):
ar=find(a)
br=find(b)
if ar==br:
return
if rank[a]>rank[b]:
parent[br]=ar
else:
parent[ar]=br
if rank[a]==rank[b]:
rank[a]+=1
def same(a,b):
ar=find(a)
br=find(b)
return ar==br
q=[None]*m
for i in range(m):
x,y,z=list(map(int,input().split()))
q[i]=[x-1,y-1]
for i in range(len(q)):
union(q[i][0],q[i][1])
roots=[0]*len(parent)
for i in range(len(parent)):
roots[i]=find(i)
print((len(set(roots))))
| import sys
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
# 0-indexed
class UnionFind:
N=0
parent=None
size=None
def __init__(self,N):
self.N=N
self.parent=[i for i in range(self.N)]
self.size=[1]*self.N
def root(self,x):
while x!=self.parent[x]:
self.parent[x]=self.parent[self.parent[x]]
x=self.parent[x]
return x
def same(self,x,y):
return self.root(x)==self.root(y)
def unite(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:
return
if self.size[x]>self.size[y]:
# 大きい方にくっつける
self.parent[y]=x
self.size[x]+=self.size[y]
else:
self.parent[x]=y
self.size[y]+=self.size[x]
def get_group_size(self,x):
return self.size[self.root(x)]
def get_roots(self):
r=set()
for i in range(self.N):
r.add(self.root(i))
return r
def show_parent(self):
print((self.parent))
def show_size(self):
print((self.size))
N,M=list(map(int,readline().split()))
UF=UnionFind(N)
for i in range(M):
x,y,z=list(map(int,readline().split()))
UF.unite(x-1,y-1)
print((len(UF.get_roots())))
| p03045 |
N, M = list(map(int,input().split()))
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
size[y] += size[x]
size[x] = 0
for i in range(M):
x, y, z= list(map(int,input().split()))
unite(x,y)
Ans = 0
for j in size[1:]:
if j != 0:
Ans +=1
print(Ans)
| N, M = list(map(int,input().split()))
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 1
par[x] = y
size[y] += size[x]
size[x] = 0
for i in range(M):
x, y, z= list(map(int,input().split()))
unite(x,y)
Ans = 0
for j in size[1:]:
if j != 0:
Ans += 1
print(Ans)
| p03045 |
import sys
sys.setrecursionlimit(10**6)
class UnionFind:
def __init__(self, N):
self.par = list(range(N))
def root(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
else:
self.par[rx] = ry
def same(self, x, y):
return self.root(x) == self.root(y)
def solve2():
N, M = [int(_) for _ in input().split()]
Tree = UnionFind(N)
for i in range(M):
Xi, Yi, Zi = [int(_) for _ in input().split()]
Xi -= 1
Yi -= 1
Tree.unite(Xi, Yi)
UnionSet = set()
for i in range(N):
UnionSet.add(Tree.root(i))
print(len(UnionSet))
if __name__ == '__main__':
solve2()
| import sys
sys.setrecursionlimit(10**6)
class MergeFind:
def __init__(self, N):
self.par = list(range(N))
self.num_sets = N
def root(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
else:
self.par[rx] = ry
self.num_sets -= 1
def same(self, x, y):
return self.root(x) == self.root(y)
def get_num_sets(self):
return self.num_sets
def solve3():
N, M = [int(_) for _ in input().split()]
Tree = MergeFind(N)
for i in range(M):
Xi, Yi, Zi = [int(_) for _ in input().split()]
Xi -= 1
Yi -= 1
Tree.unite(Xi, Yi)
print(Tree.get_num_sets())
if __name__ == '__main__':
solve3()
| p03045 |
n,m=list(map(int,input().split()))
#union-find
par=[-1]*(n+1)
def find(x):
if par[x]<0:
return x
else:
par[x]=find(par[x])
return par[x]
def size(x):
oya=find(x)
return -par[oya]
def unite(x,y):
if find(x)==find(y):
return False
else:
if size(y)>size(x):
y,x=x,y #xを大きい親にしておくか
oya_x=find(x)
oya_y=find(y)
par[oya_x]-=size(oya_y) #xの大きさをyにしておく
par[oya_y]=oya_x #yの親をxに
return True
def is_same(x,y):
return find(x)==find(y)
for _ in range(m):
x,y,z=list(map(int,input().split()))
unite(x,y)
ans_set=set()
for i in range(1,n+1):
ans_set.add(find(i))
print((len(ans_set))) | import sys
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
# union-find
# xの根を求める
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
# xとyの属する集合の併合
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return False
else:
# sizeの大きい方をxとする
if par[x] > par[y]:
x, y = y, x
par[x] += par[y]
par[y] = x
return True
# xとyが同じ集合か判定
def is_same(x, y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
# 初期化
# 根なら-size、子なら親の頂点
par = [-1] * (n + 1)
for _ in range(m):
x, y, z = list(map(int, input().split()))
unite(x, y)
ans = 0
for i in range(1, n + 1):
if i == find(i):
ans += 1
print(ans)
| p03045 |
import sys
import os
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = iss()
T = iss()
print(('Yes' if S in T*2 else 'No'))
if __name__ == '__main__':
main()
| import sys
import os
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = iss()
T = iss()
tmp = S[len(S) - 1:], S[0:len(S) - 1]
for s in range(len(S)):
t = S[s - 1:] + S[0:s - 1]
if t == T:
print('Yes')
exit()
print('No')
if __name__ == '__main__':
main()
| p03293 |
numerosStr = input().split(" ")
numeros=[]
contador=0
i=0
for j in numerosStr:
numeros.append(int(j))
A = numeros[0]
B = numeros[1]
T = numeros[2]+0.5
print((int(((T)//A)*B))) | a,b,t = list(map(int, input().split()))
if a > t:
print((0))
else:
tempo = int((t + 0.5) / a)
print((tempo * b)) | p03059 |
a, b, t = [int(x) for x in input().split()]
s = 0
x = a
while x <= t + 0.5:
s += b
x += a
print(s)
| A, B, C = list(map(int, input().split()))
ans = (int(C/A))*B
print(ans) | p03059 |
a,b,t=list(map(int,input().split()))
print((t//a*b)) | a,b,t=list(map(int,input().split()))
print((int(((t+0.5)//a)*b))) | p03059 |
import itertools
import fractions
def main():
a,b,t = list(map(int,input().split()))
print((b * (t//a)))
if __name__ == '__main__':
main() | #from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
#from fractions import gcd
#from itertools import combinations # (string,3) 3回
#from collections import deque
from collections import defaultdict
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(eval(input()))
a,b,t = readInts()
ans = 0
time = 0
while True:
ans += b
#print(time,t+0.5)
if time + a > t + 0.5:
break
else:
time += a
print((ans - b))
| p03059 |
a,b,c=list(map(int,input().split()))
print(((c//a)*b)) | a,b,t=list(map(int,input().split()))
print(((t//a)*b)) | p03059 |
a,b,t=list(map(int,input().split()))
print(((t//a)*b)) | a,b,t=list(map(int,input().split()))
print((b*(t//a))) | p03059 |
a,b,t = list(map(int, input().split()))
c = t // a
print((c*b))
| a,b,t = list(map(int,input().split()))
print((t//a * b)) | p03059 |
a,b,c=list(map(int, input().split()))
print((c//a*b))
| a, b, t = list(map(int, input().split()))
print((t // a * b)) | p03059 |
A, B, T = list(map(int, input().split()))
tmp = (T+0.5) // A
print((int(B*tmp))) | A, B, T = list(map(int, input().split()))
res = B * (T // A)
print(res) | p03059 |
# T/A * B を出力する
a,b,t = list(map(int,input().split()))
print((b*(t//a)))
| a,b,c=list(map(int,input().split()))
print(((c//a)*b)) | p03059 |
a,b,t = list(map(int,input().split()))
print(((t//a)*b)) | a,b,t = list(map(int,input().split()))
ans = t//a*b
print(ans)
| p03059 |
a, b, t = list(map(int, input().split()))
answer = int(t / a) * b
print(answer) | a,b,t=list(map(int,input().split()))
ans=int(t/a)*b
print(ans) | p03059 |
import itertools
import math
a, b, t = list(map(int, input().split()))
sum = 0
for i in range(1,21):
if a * i <= t:
sum += b
print(sum) | a, b, t = list(map(int, input().split()))
print((b*(t//a))) | p03059 |
A, B, T = list(map(int, input().split()))
ans = 0
for i in range(T+1):
if i >= A and i % A == 0:
ans += B
print(ans)
| A, B, T = list(map(int, input().split()))
ans = 0
for i in range(1, T+1):
if i % A == 0:
ans += B
print(ans)
| p03059 |
a,b,t=list(map(int,input().split()));print((t//a*b)) | a,b,c=list(map(int,input().split()))
print((c//a*b)) | p03059 |
a,b,t = list(map(int,input().split()))
s = t + 0.5
print((int((s // a) * b))) | a,b,t=list(map(int,input().split()))
t+=0.5
print((int(b*(t//a)))) | p03059 |
a,b,t = list(map(int,input().split()))
print((b*(t//a))) | a,b,t = list(map(int,input().split()))
ans = t//a*b
print(ans) | p03059 |
a, b, t = list(map(int, input().split()))
ret = 0
for i in range(a, t + 1, a):
ret += b
print(ret)
| a, b, t = list(map(int, input().split()))
print((b * (t // a))) | p03059 |
a, b, t = list(map(int, input().split()))
print((int((t+0.5)/a)*b))
| a, b, t = list(map(int, input().split()))
print((t//a*b))
| p03059 |
M = 1299710
isPrime = [1]*M
isPrime[0],isPrime[1] = 0,0
lp = [0]*M; p = []
b = 2
for i in range(2,M):
if isPrime[i]:
for j in range(i*i,M,i):
isPrime[j] = 0
p.append(i)
b = i
lp[i] = b
while 1:
n = eval(input())
if n==0: break
print(p[p.index(lp[n])+1]-lp[n] if lp[n]!=n else "0")
| M = 1299710
isPrime = [1]*M
isPrime[0],isPrime[1] = 0,0
for i in range(2,M):
if isPrime[i]:
for j in range(i*i,M,i):
isPrime[j] = 0
while 1:
n = eval(input())
if n==0: break
p = q = n
if isPrime[n]:
print(0)
else:
while isPrime[p]==0:p-=1
while isPrime[q]==0:q+=1
print(q-p)
| p00855 |
a,b,c,d,e=[int(eval(input())) for _ in range(5)]
if a<0:
print((-a*c+d+b*e))
else:
print(((b-a)*e)) | a,b,c,d,e=[int(eval(input())) for _ in range(5)]
print((-a*c+d+b*e if a<0 else (b-a)*e)) | p00553 |
def count_bigger(a, b):
i = j = 0
c = []
while i < len(a) and j < len(b):
if a[i] >= b[j]:
j += 1
continue
c.append(len(b) - j)
i += 1
if len(c) < len(a):
c += [0] * (len(a) - len(c))
for i in range(len(c) - 1, 0, -1):
c[i - 1] += c[i]
return c
def f(a, b, c):
bc = count_bigger(b, c)
i = j = ans = 0
while i < len(a) and j < len(b):
if a[i] >= b[j]:
j += 1
continue
ans += bc[j] - len(set(c) & set(2 * _b - a[i] for _b in b[j:]))
i += 1
return ans
def solve(string):
n, s = string.split()
r, g, b = [], [], []
for i, _s in enumerate(s):
if _s == "R":
r.append(i)
if _s == "G":
g.append(i)
if _s == "B":
b.append(i)
return str(f(r, g, b) + f(r, b, g) + f(b, r, g) + f(b, g, r) + f(g, r, b) + f(g, b, r))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from itertools import product
def solve(string):
n, s = string.split()
r, g, b = [], [], []
r2, g2, b2 = set([]), set([]), set([])
for i, _s in enumerate(s):
if _s == "R":
r.append(i)
r2.add(2 * i)
if _s == "G":
g.append(i)
g2.add(2 * i)
if _s == "B":
b.append(i)
b2.add(2 * i)
ans = len(r) * len(g) * len(b)
for i, j in product(r, g):
ans -= 1 if i + j in b2 else 0
for i, j in product(g, b):
ans -= 1 if i + j in r2 else 0
for i, j in product(b, r):
ans -= 1 if i + j in g2 else 0
return str(ans)
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02714 |
from sys import stdin
n = int(eval(input()))
s = stdin.readline()
rind = []
gind = []
bind = []
ans = 0
for i in range(n):
if s[i] == "R":
rind.append(i+1)
elif s[i] == "G":
gind.append(i+1)
else:
bind.append(i+1)
for i in range(len(rind)):
for j in range(len(gind)):
for k in range(len(bind)):
if (rind[i]+gind[j]!=2*bind[k])and(gind[j]+bind[k]!=2*rind[i])and(bind[k]+rind[i]!=2*gind[j]):
ans += 1
print(ans)
| from sys import stdin
n = int(eval(input()))
s = stdin.readline()
r = 0
g = 0
b = 0
for i in range(n):
if s[i] == "R":
r += 1
elif s[i] == "G":
g += 1
else:
b += 1
count1 = r*g*b
count2 = 0
for i in range(0,n-2):
for j in range(i+1,n-1):
if 2*j-i<=n-1:
if (s[i] != s[j])and(s[i] != s[2*j-i])and(s[j] != s[2*j-i]):
count2 += 1
print((count1-count2)) | p02714 |
import sys
import math
from collections import defaultdict
from collections import deque
def load(vtype=int):
return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
return [vtype(v) for v in input().strip().split(seplator)]
def exit():
import sys
sys.exit(0)
def perm_sub(li, used):
if len(li) == len(used):
return [deque()]
k = []
for i in range(len(li)):
if i in used:
continue
used.add(i)
sub_list = perm_sub(li, used)
for sub in sub_list:
sub.appendleft(li[i])
k.extend(sub_list)
used.discard(i)
return k
def perm_li(li):
return perm_sub(li, set())
def perm_n(n):
return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
return sep.join([str(e) for e in li])
def li2n(li):
n, base = 0, 1
for i in range(len(li)-1, -1, -1):
n += li[i] * base
base *= 10
return n
def sli2ili(li):
return [int(s) for s in li]
def prime_list(n):
li = [i for i in range(2, n+1)]
for i in range(len(li)):
if li[i] >= int(math.sqrt(n)):
break
if li[i] == -1:
continue
for j in range(i+1, len(li)):
if li[j] % li[i] == 0:
li[j] = -1
return [n for n in li if n != -1]
def gcd(a, b):
a, b = max(a, b), min(a, b)
while True:
r = a % b
if r == 0: return b
a, b = b, r
def lcm(a, b):
return int(a * b / gcd(a,b))
def all_subset(li):
s = []
n = len(li)
for bit in range(0, (1<<(n+1))):
ss = set()
for i in range(0, n):
if (bit & (1 << i)):
ss.add(li[i])
s.append(ss)
return s
def factorial(n):
if n == 1:
return 1
return n * factorial(n-1)
def mCn(m, n):
def factorial_ntimes(m, n):
r = 1
while n:
r *= m
m -= 1
n -= 1
return r
return int(factorial_ntimes(m, n) / factorial(n))
def notab(a, b):
s = set((a,b))
for c in "RGB":
if c not in s:
return c
n = load()
s = list(load(str))
mp = defaultdict(set)
for i in range(n):
mp[s[i]].add(i)
cnt = 0
for i in range(0, n):
first = s[i]
mp[first].remove(i)
for j in range(i + 1, n):
if s[j] == first:
continue
second = s[j]
target = notab(first, second)
for k in range(j+1, n):
if k-j == j-i or s[k] != target:
continue
# print(i, j, k)
cnt +=1
# if j + (j - i) < n:
# tmp = s[j+ (j-i)]
# cnt += s[j+1:].count(target)
# s[j+ (j-i)] = tmp
# else:
# cnt += s[j+1:].count(target)
print(cnt)
| import sys
import math
from collections import defaultdict
from collections import deque
def load(vtype=int):
return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
return [vtype(v) for v in input().strip().split(seplator)]
def notab(a, b):
s = set((a,b))
for c in "RGB":
if c not in s:
return c
n = load()
s = list(load(str))
cntmap = dict()
for c in 'RGB':
cnt = 0
cntmap[c] = [0 for _ in range(n+1)]
for i in range(n-1, -1, -1):
if s[i] == c:
cnt += 1
cntmap[c][i] = cnt
cnt = 0
for i in range(0, n):
first = s[i]
for j in range(i + 1, n):
if s[j] == first:
continue
second = s[j]
target = notab(first, second)
if j+(j-i) < n and s[j+(j-i)] == target:
cnt += cntmap[target][j+1] - 1
else:
cnt += cntmap[target][j+1]
print(cnt)
| p02714 |
from math import gcd
n=int(input().strip())
s=input().strip()
c = 0
for i in range(n-2):
for j in range(i+1,n-1):
if s[i] == s[j]:
continue
for k in range(j+1,n):
if j - i == k - j:
continue
if s[i] == s[k]:
continue
if s[j] == s[k]:
continue
c += 1
print(c)
| from math import gcd
n=int(input().strip())
s=input().strip()
r = 0
g = 0
for i in s:
if i == 'R':
r += 1
elif i == 'G':
g += 1
ans = r * g * (n - r - g)
for i in range(0, n-1):
for d in range(1, (n - i + 1) // 2):
if s[i] != s[i+d] and s[i] != s[i+d+d] and s[i+d] != s[i+d+d]:
ans -= 1
print(ans)
| p02714 |
# D - RGB Triplets
from collections import defaultdict
def main():
_ = int(eval(input()))
S = input().rstrip()
indices = defaultdict(set)
for i, c in enumerate(S):
indices[c].add(i)
cnt = len(indices["R"]) * len(indices["G"]) * len(indices["B"])
for c1, c2, c3 in ["RGB", "GBR", "BRG"]:
cnt -= sum(
(i + j) % 2 == 0 and (i + j) // 2 in indices[c3]
for i in indices[c1]
for j in indices[c2]
)
print(cnt)
if __name__ == "__main__":
main()
| # D - RGB Triplets
from collections import defaultdict
def main():
_ = int(eval(input()))
S = input().rstrip()
indices = defaultdict(set)
for i, c in enumerate(S):
indices[c].add(2 * i)
cnt = len(indices["R"]) * len(indices["G"]) * len(indices["B"])
for c1, c2, c3 in ["RGB", "GBR", "BRG"]:
cnt -= sum(
(i + j) // 2 in indices[c3] for i in indices[c1] for j in indices[c2]
)
print(cnt)
if __name__ == "__main__":
main()
| p02714 |
# D - RGB Triplets
from collections import defaultdict
def main():
_, S = open(0).read().split()
indices, doubled_indices = defaultdict(list), defaultdict(set)
for i, c in enumerate(S):
indices[c].append(i)
doubled_indices[c].add(2 * i)
cnt = S.count("R") * S.count("G") * S.count("B")
for x, y, z in ["RGB", "GBR", "BRG"]:
cnt -= sum(i + j in doubled_indices[z] for i in indices[x] for j in indices[y])
print(cnt)
if __name__ == "__main__":
main()
| # D - RGB Triplets
from collections import defaultdict
def main():
_, S = open(0).read().split()
indices, doubled_indices = defaultdict(list), defaultdict(set)
for i, c in enumerate(S):
indices[c].append(i)
doubled_indices[c].add(2 * i)
cnt = len(indices["R"]) * len(indices["G"]) * len(indices["B"])
for x, y, z in ("RGB", "RBG", "BGR"):
cnt -= sum(i + j in doubled_indices[z] for i in indices[x] for j in indices[y])
print(cnt)
if __name__ == "__main__":
main()
| p02714 |
from sys import stdin
import bisect
def main():
#入力
readline=stdin.readline
N=int(readline())
S=readline().strip()
res=0
R=[]
G=[]
B=[]
flags=[""]*N
for i in range(N):
if S[i]=="R":
R.append(i)
flags[i]="R"
elif S[i]=="G":
G.append(i)
flags[i]="G"
else:
B.append(i)
flags[i]="B"
#Bが最後
for i in range(len(R)):
for j in range(len(G)):
n=max(R[i],G[j])
k=bisect.bisect_left(B,n)
res+=len(B)-k
if n+n-min(R[i],G[j])<N:
if flags[n+n-min(R[i],G[j])]=="B":
res-=1
for i in range(len(R)):
for j in range(len(B)):
n=max(R[i],B[j])
k=bisect.bisect_left(G,n)
res+=len(G)-k
if n+n-min(R[i],B[j])<N:
if flags[n+n-min(R[i],B[j])]=="G":
res-=1
for i in range(len(B)):
for j in range(len(G)):
n=max(B[i],G[j])
k=bisect.bisect_left(R,n)
res+=len(R)-k
if n+n-min(B[i],G[j])<N:
if flags[n+n-min(B[i],G[j])]=="R":
res-=1
print(res)
if __name__=="__main__":
main() | from sys import stdin
def main():
#入力
readline=stdin.readline
n=int(readline())
s=readline().strip()
ans=s.count("R")*s.count("G")*s.count("B")
for i in range(n):
for j in range(i+1,n):
k=2*j-i
if k>=n: break
x=s[i]
y=s[j]
z=s[k]
if x!=y and y!=z and z!=x:
ans-=1
print(ans)
if __name__=="__main__":
main() | p02714 |
n,s=open(0);n=int(n);c=s.count;print((c('R')*c('G')*c('B')-sum(len(set(s[i:j+1:j-i>>1]))>2for i in range(n)for j in range(i+2,n,2)))) | n,s=open(0);n=int(n);c=s.count;print((c('R')*c('G')*c('B')-sum(s[i]!=s[j]!=s[i+j>>1]!=s[i]for i in range(n)for j in range(i+2,n,2)))) | p02714 |
n,s=open(0);n=int(n);c=s.count;print((c('R')*c('G')*c('B')-sum(s[i]!=s[j]!=s[i+j>>1]!=s[i]for i in range(n)for j in range(i+2,n,2)))) | n,s=open(0);n=int(n);c=s.count;print((c('R')*c('G')*c('B')-sum(s[i]!=s[i+j>>1]!=s[j]!=s[i]for i in range(n)for j in range(i+2,n,2)))) | p02714 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop
INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: list(map(int, INPUT().split()))
S_MAP = lambda: list(map(str, INPUT().split()))
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
def main():
N = INT()
S = INPUT()
cnt = 0
for i, j, k in list(combinations(list(range(N)), 3)):
if j - i == k - j: continue
if S[i] == S[j] or S[j] == S[k] or S[k] == S[i]: continue
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop
INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: list(map(int, INPUT().split()))
S_MAP = lambda: list(map(str, INPUT().split()))
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
def main():
N = INT()
S = INPUT()
R = []
G = []
B = []
for i, s in enumerate(S):
if s == 'R': R.append(i + 1)
elif s == 'G': G.append(i + 1)
else: B.append(i + 1)
cnt = 0
for r in R:
for g in G:
for b in B:
i = min(r, g, b)
k = max(r, g, b)
for x in [r, g, b]:
if i < x < k: j = x
if j - i != k - j: cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| p02714 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def inp():
return int(input())
def inps():
return input().rstrip()
def inpl():
return list(map(int, input().split()))
def _debug(obj):
print(obj, file=sys.stderr)
# import decimal
# from decimal import Decimal
# decimal.getcontext().prec = 10
# from heapq import heappush, heappop, heapify
# import math
# from math import gcd
# import itertools as it
# import collections
# from collections import deque
# ---------------------------------------
N = inp()
S = inps()
r = []
g = []
b = []
for i in range(N):
if S[i] == "R":
r.append(i)
if S[i] == "G":
g.append(i)
if S[i] == "B":
b.append(i)
ans = 0
for i in r:
for j in g:
for k in b:
if abs(i - j) != abs (j - k) and abs(i - j) != abs (i - k) and abs(i - k) != abs (j - k):
ans += 1
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def inp():
return int(input())
def inps():
return input().rstrip()
def inpl():
return list(map(int, input().split()))
def _debug(obj):
print(obj, file=sys.stderr)
# import decimal
# from decimal import Decimal
# decimal.getcontext().prec = 10
# from heapq import heappush, heappop, heapify
# import math
# from math import gcd
# import itertools as it
# import collections
# from collections import deque
# ---------------------------------------
N = inp()
S = inps()
r = []
g = []
b = []
for i in range(N):
if S[i] == "R":
r.append(i)
if S[i] == "G":
g.append(i)
if S[i] == "B":
b.append(i)
ans = 0
for i in r:
for j in g:
m = i
n = j
if m > n:
m, n = n, m
sa = abs(m - n)
ans += len(b)
if m - sa >= 0 and S[m - sa] == "B":
ans -= 1
if n + sa < N and S[n + sa] == "B":
ans -= 1
if sa % 2 == 0 and S[m + sa//2] == "B":
ans -= 1
print(ans)
| p02714 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()
N = i_i()
S = i_s()
ans = 0
for i in range(N):
for j in range(i, N):
if S[i] != S[j]:
if S[i] == 'R' and S[j] == 'G':
tmp = 'B'
elif S[i] == 'R' and S[j] == 'B':
tmp = 'G'
elif S[i] == 'G' and S[j] == 'R':
tmp = 'B'
elif S[i] == 'B' and S[j] == 'R':
tmp = 'G'
else:
tmp = 'R'
if tmp in S[j:]:
for k in range(j, N):
if S[k] == tmp and k - j != j - i:
ans += 1
print(ans) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()
N = i_i()
S = i_s()
r = S.count('R')
g = S.count('G')
b = S.count('B')
cnt = 0
for i in range(N):
for j in range(i+1, N):
k = j + j - i
if k >= N:
break
if S[i] != S[j] and S[j] != S[k] and S[i] != S[k]:
cnt += 1
print(((r * g * b) - cnt)) | p02714 |
def main():
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
A=[]
B=[]
for i in range():
a, b = map(int, input().split())
A.append(a)
B.append(b)'''
n=int(eval(input()))
s=input().rstrip('\n')
from collections import Counter
a=Counter(s)
#print(a)
num=a["R"]*a["G"]*a["B"]
#print(num)
for i in range(n-2):
for j in range(1,n//2+1):
if i+2*j<n:
#print([i,i+j,i+2*j,s[i], s[i+j], s[i+2*j]])
if set([s[i],s[i+j],s[i+2*j]])==set(["R","G","B"]):
num-=1
print(num)
if __name__ == "__main__":
main() |
def main():
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
A=[]
B=[]
for i in range():
a, b = map(int, input().split())
A.append(a)
B.append(b)'''
n=int(eval(input()))
s=input().rstrip('\n')
a=0
b=0
c=0
for i in range(n):
if s[i]=="R":
a+=1
elif s[i]=="G":
b+=1
elif s[i]=="B":
c+=1
num=a*b*c
#print(num)
for i in range(n-2):
for j in range(1,n//2+1):
if i+2*j<n:
if s[i]!=s[i+j] and s[i+j]!=s[i+2*j] and s[i]!=s[i+2*j]:
num-=1
print(num)
if __name__ == "__main__":
main()
| p02714 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from bisect import bisect_left
def resolve():
N = ir()
S = sr()
R = []
G = []
B = []
for i in range(N):
if S[i] == 'R':
R.append(i)
elif S[i] == 'G':
G.append(i)
else:
B.append(i)
ans = 0
for r in R:
for g in G:
for b in B:
rg = abs(r-g)
gb = abs(g-b)
br = abs(b-r)
if rg != gb and gb != br and br != rg:
ans += 1
# i = min(r, g, b)
# k = max(r, g, b)
# a = k-i
# if a != 2*r and a != 2*g and a != 2*b:
# ans += 1
# for n in R:
# # x = bisect_left(G, n)
# for i in G:
# a = max(n, i)
# b = min(n, i)
# x = bisect_left(B, a)
# ans += len(B[x:])
# if 2*a-b in B:
# ans -= 1
# for n in R:
# # x = bisect_left(B, n)
# for i in B:
# a = max(n, i)
# b = min(n, i)
# x = bisect_left(G, a)
# ans += len(G[x:])
# if 2*a-b in G:
# ans -= 1
# # for n in G:
# # x = bisect_left(R, n)
# # for i in R[x:]:
# # x = bisect_left(B, i)
# # ans += len(B[x:])
# # if 2*i-n in B:
# # ans -= 1
# for n in G:
# # x = bisect_left(B, n)
# for i in B:
# a = max(n, i)
# b = min(n, i)
# x = bisect_left(R, a)
# ans += len(R[x:])
# if 2*a-b in R:
# ans -= 1
# for n in B:
# x = bisect_left(R, n)
# for i in R[x:]:
# x = bisect_left(G, i)
# ans += len(G[x:])
# if 2*i-n in G:
# ans -= 1
# for n in B:
# x = bisect_left(G, n)
# for i in G[x:]:
# x = bisect_left(R, i)
# ans += len(R[x:])
# if 2*i-n in R:
# ans -= 1
print(ans)
resolve() | import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
from bisect import bisect_left
def resolve():
N = ir()
S = sr()
R = []
G = []
B = []
for i in range(N):
if S[i] == 'R':
R.append(i+1)
elif S[i] == 'G':
G.append(i+1)
else:
B.append(i+1)
ans = len(R)*len(G)*len(B)
for r in R:
for g in G:
if abs(r+g)%2 == 0:
if abs(r+g)//2 in B:
ans -= 1
for r in B:
for g in G:
if abs(r+g)%2 == 0:
if abs(r+g)//2 in R:
ans -= 1
for r in R:
for g in B:
if abs(r+g)%2 == 0:
if abs(r+g)//2 in G:
ans -= 1
# for b in B:
# rg = abs(r-g)
# gb = abs(g-b)
# br = abs(b-r)
# if rg != gb and gb != br and br != rg:
# ans += 1
# i = min(r, g, b)
# k = max(r, g, b)
# a = k-i
# if a != 2*r and a != 2*g and a != 2*b:
# ans += 1
# for n in R:
# # x = bisect_left(G, n)
# for i in G:
# a = max(n, i)
# b = min(n, i)
# x = bisect_left(B, a)
# ans += len(B[x:])
# if 2*a-b in B:
# ans -= 1
# for n in R:
# # x = bisect_left(B, n)
# for i in B:
# a = max(n, i)
# b = min(n, i)
# x = bisect_left(G, a)
# ans += len(G[x:])
# if 2*a-b in G:
# ans -= 1
# # for n in G:
# # x = bisect_left(R, n)
# # for i in R[x:]:
# # x = bisect_left(B, i)
# # ans += len(B[x:])
# # if 2*i-n in B:
# # ans -= 1
# for n in G:
# # x = bisect_left(B, n)
# for i in B:
# a = max(n, i)
# b = min(n, i)
# x = bisect_left(R, a)
# ans += len(R[x:])
# if 2*a-b in R:
# ans -= 1
# for n in B:
# x = bisect_left(R, n)
# for i in R[x:]:
# x = bisect_left(G, i)
# ans += len(G[x:])
# if 2*i-n in G:
# ans -= 1
# for n in B:
# x = bisect_left(G, n)
# for i in G[x:]:
# x = bisect_left(R, i)
# ans += len(R[x:])
# if 2*i-n in R:
# ans -= 1
print(ans)
resolve() | p02714 |
from itertools import permutations
inputs = open(0).readlines()
n = int(inputs[0])
S = inputs[1].strip()
R = [i for i, c in enumerate(S) if c == 'R']
G = [i for i, c in enumerate(S) if c == 'G']
B = [i for i, c in enumerate(S) if c == 'B']
def f(Z, i, x, y):
for z in Z[i:]:
if z == 2*y-x:
return 1
if z > 2*y-x:
return 0
return 0
ans = 0
for X, Y, Z in list(permutations([R, G, B])):
for x in X:
pi = 0
for y in Y:
if x < y:
for i, z in enumerate(Z[pi:], pi):
if y < z:
ans += len(Z) - i - f(Z, i, x, y)
pi = i
break
print(ans) | n = int(eval(input()))
S = input().strip()
r, g, b = list(map(S.count, 'RGB'))
t = 0
for i in range(n-2):
for w in range(1, (n-i+1) // 2):
t += len({S[i], S[i+w], S[i+2*w]}) == 3
print((r*g*b - t)) | p02714 |
from sys import stdin
N = list(map(int, (stdin.readline().strip().split())))[0]
S= list(stdin.readline().strip())
ans=0
for i in range(1,N+1):
for j in range(i+1,N+1):
for k in range(j+1,N+1):
if j-i !=k-j:
if S[i-1] != S[j-1] and S[j-1] !=S[k-1] and S[i-1] != S[k-1]:
ans+=1
print(ans) | from sys import stdin
N = list(map(int, (stdin.readline().strip().split())))[0]
S= list(stdin.readline().strip())
ans = S.count("R")*S.count("G")*S.count("B")
for i in range(N):
for j in range(i+1,N):
k=2*j-i
if k>=N:break
if S[i]!=S[j] and S[j]!=S[k] and S[i] !=S[k]:
ans-=1
print(ans) | p02714 |
# import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
N = int(eval(input()))
S = input().rstrip()
all = {'R','G','B'}
R = set([])
G = set([])
B = set([])
for i in range(N):
temp = S[i]
if temp == 'R':
R.add(i)
elif temp == 'G':
G.add(i)
else:
B.add(i)
res = len(R) * len(G) * len(B)
count = 0
for r in R:
for g in G:
for b in B:
l = [r,g,b]
l.sort()
if l[1]-l[0] == l[2]-l[1]:
count += 1
res -= count
print(res)
main()
| # import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
N = int(eval(input()))
S = input().rstrip()
R = set([])
G = set([])
B = set([])
for i in range(N):
temp = S[i]
if temp == 'R':
R.add(i)
elif temp == 'G':
G.add(i)
else:
B.add(i)
all = [R,G,B]
M = [len(R),len(G),len(B)]
res = M[0] * M[1] * M[2]
index = M.index(max(M))
most = all.pop(index)
first = all[0]
second = all[1]
count = 0
for f in first:
for s in second:
temp1 = s * 2 - f
temp2 = f * 2 - s
temp3 = (f + s) // 2
if (True) & (temp1 in most):
count += 1
if (True) & (temp2 in most):
count += 1
if (s + f) % 2 == 0:
if temp3 in most:
count += 1
res -= count
print(res)
main()
| p02714 |
from sys import stdin
n = int(stdin.readline().rstrip())
s = str(stdin.readline().rstrip())
#l = list(map(int, stdin.readline().rstrip().split()))
#A, B, C = map(int, stdin.readline().rstrip().split())
#S = [list(map(int, stdin.readline().rstrip().split())) for _ in range(h)]#hの定義を忘れずに
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if s[i]!=s[j] and s[i]!=s[k] and s[j]!=s[k]:
if j-i!=k-j:
ans += 1
print(ans)
| from sys import stdin
n = int(stdin.readline().rstrip())
s = str(stdin.readline().rstrip())
#l = list(map(int, stdin.readline().rstrip().split()))
#A, B, C = map(int, stdin.readline().rstrip().split())
#S = [list(map(int, stdin.readline().rstrip().split())) for _ in range(h)]#hの定義を忘れずに
rnum = s.count("R")
gnum = s.count("G")
bnum = s.count("B")
ans = rnum * gnum * bnum
for i in range(n-2):
for j in range(i+1,n-1):
k = 2*j - i
if k<n:
if s[i]!=s[j] and s[j]!=s[k] and s[i]!=s[k]:
ans -= 1
print(ans)
| p02714 |
import sys
n = int(sys.stdin.readline().rstrip())
s = sys.stdin.readline().rstrip()
r = []
b = []
g = []
for i, si in enumerate(s):
if si == 'R':
r.append(i + 1)
elif si == 'G':
g.append(i + 1)
elif si == 'B':
b.append(i + 1)
count = 0
gb = sorted(g + b)
br = sorted(b + r)
rg = sorted(r + g)
for i, si in enumerate(s):
tmp = None
if si == 'R':
tmp = gb
elif si == 'G':
tmp = br
else:
tmp = rg
for j in tmp:
if j < i + 1:
continue
tmp2 = None
# print(si, s[j-1])
if (si == 'R' and s[j-1] == 'G') or (si == 'G' and s[j-1] == 'R'):
tmp2 = b
elif (si == 'R' and s[j-1] == 'B') or (si == 'B' and s[j-1] == 'R'):
tmp2 = g
elif (si == 'G' and s[j-1] == 'B') or (si == 'B' and s[j-1] == 'G'):
tmp2 = r
for k in tmp2:
if k < j:
continue
if j - (i + 1) != k - j:
# print(i + 1, j, k)
count += 1
print(count) | import sys
n = int(sys.stdin.readline().rstrip())
s = sys.stdin.readline().rstrip()
r = []
b = []
g = []
for i, si in enumerate(s):
if si == 'R':
r.append(i + 1)
elif si == 'G':
g.append(i + 1)
elif si == 'B':
b.append(i + 1)
count = 0
for i in range(n):
for j in range(i + 1, n):
k = j + j - i
if k < n and s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
count += 1
print((len(r) * len(g) * len(b) - count))
| p02714 |
n = int(eval(input()))
seq = input().strip()
ans = 0
r = []
g = []
b = []
for i in range(len(seq)):
if seq[i] == 'R':
r.append(i)
elif seq[i] == 'G':
g.append(i)
else:
b.append(i)
for i in r:
for j in g:
for k in b:
z,x,c = sorted([i,j,k])
if x-z != c - x:
ans += 1
print(ans) | n = int(eval(input()))
seq = input().strip()
ans = 0
r = set()
g = set()
b = set()
for i in range(len(seq)):
if seq[i] == 'R':
r.add(i)
elif seq[i] == 'G':
g.add(i)
else:
b.add(i)
ans = len(r)*len(g)*len(b)
for i in r:
for j in g:
if (i+j) % 2 == 0 and ((i + j) //2) in b:
ans -= 1
if max(i,j) + (max(i,j) - min(i,j)) in b:
ans -= 1
if min(i,j) - (max(i,j) - min(i,j)) in b:
ans -= 1
print(ans) | p02714 |
import sys
import fractions
def in_ctrl():
_input = [_.rstrip() for _ in sys.stdin.readlines()]
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
N = int(_input[0])
S = _input[1]
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return N,S
def out_ctrl(s):
print(s)
if __name__ == "__main__":
N,S = in_ctrl()
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
cnt = 0
R = list(map(bool,list(map(int,list(S.replace('R','1').replace('G','0').replace('B','0'))))))
G = list(map(bool,list(map(int,list(S.replace('R','0').replace('G','1').replace('B','0'))))))
B = list(map(bool,list(map(int,list(S.replace('R','0').replace('G','0').replace('B','1'))))))
R_cum, G_cum, B_cum = {}, {}, {}
for i,r in enumerate(R):
if r:
for j,g in enumerate(G[i+1:]):
if g:
if i+j+2 not in B_cum:
B_cum[i+j+2] = sum(B[i+j+2:])
if i+2*j+2 < N:
cnt += B_cum[i+j+2] - B[i+2*j+2]
else:
cnt += B_cum[i+j+2]
for j,g in enumerate(B[i+1:]):
if g:
if i+j+2 not in G_cum:
G_cum[i+j+2] = sum(G[i+j+2:])
if i+2*j+2 < N:
cnt += G_cum[i+j+2] - G[i+2*j+2]
else:
cnt += G_cum[i+j+2]
for i,r in enumerate(G):
if r:
for j,g in enumerate(R[i+1:]):
if g:
if i+j+2 not in B_cum:
B_cum[i+j+2] = sum(B[i+j+2:])
if i+2*j+2 < N:
cnt += B_cum[i+j+2] - B[i+2*j+2]
else:
cnt += B_cum[i+j+2]
for j,b in enumerate(B[i+1:]):
if b:
if i+j+2 not in R_cum:
R_cum[i+j+2] = sum(R[i+j+2:])
if i+2*j+2 < N:
cnt += R_cum[i+j+2] - R[i+2*j+2]
else:
cnt += R_cum[i+j+2]
for i,r in enumerate(B):
if r:
for j,g in enumerate(R[i+1:]):
if g:
if i+j+2 not in G_cum:
G_cum[i+j+2] = sum(G[i+j+2:])
if i+2*j+2 < N:
cnt += G_cum[i+j+2] - G[i+2*j+2]
else:
cnt += G_cum[i+j+2]
for j,b in enumerate(G[i+1:]):
if b:
if i+j+2 not in R_cum:
R_cum[i+j+2] = sum(R[i+j+2:])
if i+2*j+2 < N:
cnt += R_cum[i+j+2] - R[i+2*j+2]
else:
cnt += R_cum[i+j+2]
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
out_ctrl(cnt) | from sys import stdin
if __name__ == "__main__":
_in = [_.rstrip() for _ in stdin.readlines()]
N = int(_in[0]) # type:int
S = _in[1] # type:str
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
cnt = S.count('R')*S.count('G')*S.count('B')
for i in range(N):
for j in range(i+1,N):
k = 2*j-i
if k<N:
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
cnt -= 1
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(cnt)
| p02714 |
# this is a good problem !
import sys
si = sys.stdin.readline
d = ['R', 'G', 'B']
ld = [[], [], []] # letter distribution
def main():
count = 0
n = int(si())
l = list(si())
l.pop()
dc = d[:]
for i in range(n-1, -1, -1):
if i == n-1:
if l[i] == 'R':
ld[0].append(1)
ld[1].append(0)
ld[2].append(0)
elif l[i] == 'G':
ld[0].append(0)
ld[1].append(1)
ld[2].append(0)
else:
ld[0].append(0)
ld[1].append(0)
ld[2].append(1)
else:
if l[i] == 'R':
ld[0] = [ld[0][0]+1]+ld[0]
ld[1] = [ld[1][0]+0]+ld[1]
ld[2] = [ld[2][0]+0]+ld[2]
elif l[i] == 'G':
ld[0] = [ld[0][0]+0]+ld[0]
ld[1] = [ld[1][0]+1]+ld[1]
ld[2] = [ld[2][0]+0]+ld[2]
else:
ld[0] = [ld[0][0]+0]+ld[0]
ld[1] = [ld[1][0]+0]+ld[1]
ld[2] = [ld[2][0]+1]+ld[2]
for i in range(n-2):
r1 = l[i]
dc.remove(r1)
for j in range(i+1, n-1):
if l[j] in dc:
r2 = l[j]
dc.remove(r2)
count += ld[d.index(dc[0])][j+1]
if (j+j-i) < n and l[j+j-i] in dc:
count -= 1
dc += [r2]
dc += [r1]
print(count)
if __name__ == '__main__':
main()
| import sys
si = sys.stdin.readline
so = sys.stdout.write
def main():
n = int(si())
s = si()[:-1]
cnt = s.count('R')*s.count('G')*s.count('B')
for i in range(n-2):
for j in range(i+1, n-1):
k = j+j-i
if k < n and s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
cnt -= 1
print(cnt)
if __name__ == '__main__':
main()
| p02714 |
import math
import sys
import os
from operator import mul
import bisect
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
N = I()
S = list(_S())
ans = 0
r = []
g = []
b = []
for i,s in enumerate(S):
if s == 'R':
r.append(i)
if s == 'G':
g.append(i)
if s == 'B':
b.append(i)
# j = bisect.bisect_right(<list>,<value>)
# print(r)
# print(g)
# print(b)
for i in r:
for j in g:
for k in b:
tmp = sorted([i,j,k])
if not tmp[1]-tmp[0]==tmp[2]-tmp[1]:
ans += 1
# for i in range(N):
# for j in range(i,N):
# for k in range(j,N):
# if S[i]==S[j]:
# continue
# if S[i]==S[k] or S[j]==S[k]:
# continue
# if (j-i) == (k-j):
# continue
# ans += 1
print(ans)
# R G B
# R B G
# G B R
# G R B
# B G R
# B R G
# i j k
# - != -
# RBRBGRBGGB
# 1122233333
# 0000111233
# 0112223334
# B*3
# G*4
# GB系: (2,4), (4,5)
# RB系: (1,3), | import math
import sys
import os
from operator import mul
import bisect
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
N = I()
S = list(_S())
ans = 0
r = []
g = []
b = []
for i,s in enumerate(S):
if s == 'R':
r.append(i)
if s == 'G':
g.append(i)
if s == 'B':
b.append(i)
# j = bisect.bisect_right(<list>,<value>)
# print(r)
# print(g)
# print(b)
# for i in r:
# for j in g:
# for k in b:
# tmp = sorted([i,j,k])
# if not tmp[1]-tmp[0]==tmp[2]-tmp[1]:
# ans += 1
ans = len(r)*len(g)*len(b)
for i in range(N):
for j in range(i,N):
k = j + (j-i)
if k > N-1:
break
if S[i]==S[j]:
continue
if S[i]==S[k] or S[j]==S[k]:
continue
ans -= 1
print(ans)
# R G B
# R B G
# G B R
# G R B
# B G R
# B R G
# i j k
# - != -
# RBRBGRBGGB
# 1122233333
# 0000111233
# 0112223334
# B*3
# G*4
# GB系: (2,4), (4,5)
# RB系: (1,3), | p02714 |
import sys
input = sys.stdin.readline
def linput():
return [int(x) for x in input().split()]
n = int(eval(input()))
s = input().rstrip()
from collections import Counter
r = []
g = []
b = []
for i in range(n):
if s[i] == "R":
r.append(i)
elif s[i] == "G":
g.append(i)
else:
b.append(i)
cr = Counter(r)
cg = Counter(g)
cb = Counter(b)
import bisect
from copy import deepcopy
ans = 0
for i in range(n):
for j in range(i + 1, n):
if s[i] == s[j]:
continue
ng = j + (j - i)
if s[i] == "R" and s[j] == "G":
l = deepcopy(b)
c = cb
elif s[i] == "R" and s[j] == "B":
l = deepcopy(g)
c = cg
elif s[i] == "G" and s[j] == "R":
l = deepcopy(b)
c = cb
elif s[i] == "G" and s[j] == "B":
l = deepcopy(r)
c = cr
elif s[i] == "B" and s[j] == "R":
l = deepcopy(g)
c = cg
elif s[i] == "B" and s[j] == "G":
l = deepcopy(r)
c = cr
ans += len(l) - bisect.bisect_right(l, j)
ans -= c[j + (j - i)]
print(ans)
| import sys
input = sys.stdin.readline
def linput():
return [int(x) for x in input().split()]
n = int(eval(input()))
s = input().rstrip()
from collections import Counter
r = [0] * (n + 1)
g = [0] * (n + 1)
b = [0] * (n + 1)
for i in range(1, n + 1):
if s[i - 1] == "R":
r[i] = r[i - 1] + 1
else:
r[i] = r[i - 1]
if s[i - 1] == "G":
g[i] = g[i - 1] + 1
else:
g[i] = g[i - 1]
if s[i - 1] == "B":
b[i] = b[i - 1] + 1
else:
b[i] = b[i - 1]
ans = 0
for i in range(n):
for j in range(i + 1, n - 1):
if s[i] == s[j]:
continue
ng = j + (j - i) + 1
if s[i] == "R" and s[j] == "G":
l = b
elif s[i] == "R" and s[j] == "B":
l = g
#c = cg
elif s[i] == "G" and s[j] == "R":
l = b
#c = cb
elif s[i] == "G" and s[j] == "B":
l = r
#c = cr
elif s[i] == "B" and s[j] == "R":
l = g
#c = cg
elif s[i] == "B" and s[j] == "G":
l = r
#c = cr
ans += l[n] - l[j + 1]
if ng < n + 1:
ans -= l[ng] - l[ng - 1]
#print(ans)
print(ans)
| p02714 |
from itertools import accumulate, dropwhile
from sys import stdin
def main():
N = int(stdin.readline().rstrip())
S = stdin.readline().rstrip()
r_sum, g_sum, b_sum = [list(accumulate(1 if c == x else 0 for c in S)) for x in 'RGB']
sums = {'R': r_sum, 'G': g_sum, 'B': b_sum}
r_idx, g_idx, b_idx = [[i for i, c in enumerate(S) if c == x] for x in 'RGB']
idxs = {'R': sorted(g_idx + b_idx), 'G': sorted(r_idx + b_idx), 'B': sorted(r_idx + g_idx)}
ans = 0
for i in range(N - 2):
idxs[S[i]] = list(dropwhile(lambda x: i > x, idxs[S[i]]))
for j in idxs[S[i]]:
other = 'RGB'.replace(S[i], '').replace(S[j], '')
ans += sums[other][-1] - sums[other][j]
k = j + (j - i)
if k < N and S[k] == other:
ans -= 1
print(ans)
if __name__ == '__main__':
main()
| from sys import stdin
def main():
N = int(stdin.readline().rstrip())
S = stdin.readline().rstrip()
r_count, g_count, b_count = [S.count(x) for x in 'RGB']
ans = r_count * g_count * b_count
for i in range(N - 2):
for j in range(i + 1, N - 1):
k = j + (j - i)
if k < N and (S[i] != S[j] and S[j] != S[k] and S[k] != S[i]):
ans -= 1
print(ans)
if __name__ == '__main__':
main()
| p02714 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def main():
n = II()
s = IS()
r,g,b=[],[],[]
def binary_search(lst, K):
l = 0; r = len(lst);
while(l+1<r):
mid = (l+r)//2
#下記の操作を書き換えることによって探索条件を変更可能
if(lst[mid]>K): r=mid
else: l=mid
return l
for i,ss in enumerate(s):
if ss=='R':
r.append(i)
elif ss=='G':
g.append(i)
else:
b.append(i)
ans=len(r)*len(g)*len(b)
for rr in r:
for gg in g:
a=max(rr,gg)+abs(rr-gg)
if a in b:
ans-=1
a=min(rr,gg)-abs(rr-gg)
if a in b:
ans-=1
if((rr+gg)%2==0):
a=(rr+gg)//2
if a in b:
ans-=1
print(ans)
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def main():
n = II()
s = IS()
r,g,b=[],[],[]
def binary_search(lst, K):
l = 0; r = len(lst);
while(l+1<r):
mid = (l+r)//2
#下記の操作を書き換えることによって探索条件を変更可能
if(lst[mid]>K): r=mid
else: l=mid
return l
for i,ss in enumerate(s):
if ss=='R':
r.append(i)
elif ss=='G':
g.append(i)
else:
b.append(i)
ans=len(r)*len(g)*len(b)
for rr in r:
for gg in g:
a=max(rr,gg)+abs(rr-gg)
if(a<n):
if(s[a]=="B"):
ans-=1
a=min(rr,gg)-abs(rr-gg)
if(a<n and a>=0):
if(s[a]=="B"):
ans-=1
if((rr+gg)%2==0):
a=(rr+gg)//2
if(a<n):
if(s[a]=="B"):
ans-=1
print(ans)
if __name__ == '__main__':
main()
| p02714 |
from bisect import bisect_right
N = int(eval(input()))
S = input().strip()
R = []
G = []
B = []
Ron = [0 for _ in range(len(S))]
Gon = [0 for _ in range(len(S))]
Bon = [0 for _ in range(len(S))]
for i in range(N):
if S[i]=="R":
R.append(i)
Ron[i]=1
elif S[i]=="G":
G.append(i)
Gon[i]=1
else:
B.append(i)
Bon[i]=1
cnt = 0
for i in range(N):
if Ron[i]==1:
#RGB
indr = i
ind0 = bisect_right(G,indr)
for j in range(ind0,len(G)):
indg = G[j]
if len(B)>0:
ind1 = bisect_right(B,indg)
if 2*indg-indr>B[-1] or Bon[2*indg-indr]==0 or Bon[2*indg-indr]==1 and 2*indg-indr<B[ind1]:
cnt += len(B)-ind1
else:
cnt += len(B)-ind1-1
#RBG
ind0 = bisect_right(B,indr)
for j in range(ind0,len(B)):
indb = B[j]
if len(G)>0:
ind1 = bisect_right(G,indb)
if 2*indb-indr>G[-1] or Gon[2*indb-indr]==0 or Gon[2*indb-indr]==1 and 2*indb-indr<G[ind1]:
cnt += len(G)-ind1
else:
cnt += len(G)-ind1-1
elif Gon[i]==1:
#GBR
indg = i
ind0 = bisect_right(B,indg)
for j in range(ind0,len(B)):
indb = B[j]
if len(R)>0:
ind1 = bisect_right(R,indb)
if 2*indb-indg>R[-1] or Ron[2*indb-indg]==0 or Ron[2*indb-indg]==1 and 2*indb-indg<R[ind1]:
cnt += len(R)-ind1
else:
cnt += len(R)-ind1-1
#GRB
ind0 = bisect_right(R,indg)
for j in range(ind0,len(R)):
indr = R[j]
if len(B)>0:
ind1 = bisect_right(B,indr)
if 2*indr-indg>B[-1] or Bon[2*indr-indg]==0 or Bon[2*indr-indg]==1 and 2*indr-indg<B[ind1]:
cnt += len(B)-ind1
else:
cnt += len(B)-ind1-1
elif Bon[i]==1:
#BRG
indb = i
ind0 = bisect_right(R,indb)
for j in range(ind0,len(R)):
indr = R[j]
if len(G)>0:
ind1 = bisect_right(G,indr)
if 2*indr-indb>G[-1] or Gon[2*indr-indb]==0 or Gon[2*indr-indb]==1 and 2*indr-indb<G[ind1]:
cnt += len(G)-ind1
else:
cnt += len(G)-ind1-1
#BGR
ind0 = bisect_right(G,indb)
for j in range(ind0,len(G)):
indg = G[j]
if len(R)>0:
ind1 = bisect_right(R,indg)
if 2*indg-indb>R[-1] or Ron[2*indg-indb]==0 or Ron[2*indg-indb]==1 and 2*indg-indb<R[ind1]:
cnt += len(R)-ind1
else:
cnt += len(R)-ind1-1
print(cnt) | N = int(eval(input()))
S = input().strip()
C = {"R":[],"G":[],"B":[]}
for i in range(N):
C[S[i]].append(i)
C["B"] = set(C["B"])
cnt = 0
for r in C["R"]:
for g in C["G"]:
if r<g:
i = r
j = g
else:
i = g
j = r
cnt += len(C["B"])
if i-(j-i) in C["B"]:
cnt -= 1
if j+(j-i) in C["B"]:
cnt -= 1
if (j+i)%2==0 and (j+i)//2 in C["B"]:
cnt -= 1
print(cnt) | p02714 |
from sys import stdin
def get_result(data):
# N = int(data[0][0])
S = data[1][0]
r_index = [i for i in range(len(S)) if S[i] == 'R']
g_index = [i for i in range(len(S)) if S[i] == 'G']
b_index = [i for i in range(len(S)) if S[i] == 'B']
all_case = len(r_index) * len(g_index) * len(b_index)
invalid_case = 0
for i in r_index:
for j in g_index:
s_i, s_j = sorted([i, j])
tmp_max_b = s_j + (s_j-s_i)
if tmp_max_b in b_index:
invalid_case += 1
tmp_min_b = s_i - (s_j-s_i)
if tmp_min_b in b_index:
invalid_case += 1
tmp_mid_b = (s_i + s_j) / 2
if tmp_mid_b in b_index:
invalid_case += 1
return all_case - invalid_case
if __name__ == '__main__':
raw_data = [val.rstrip() for val in stdin.readlines()]
data = [list(map(str, val.split(' '))) for val in raw_data]
result = get_result(data)
print(result)
| from sys import stdin
def get_result(data):
# N = int(data[0][0])
S = data[1][0]
r_index = [i for i in range(len(S)) if S[i] == 'R']
g_index = [i for i in range(len(S)) if S[i] == 'G']
b_index = set([i for i in range(len(S)) if S[i] == 'B'])
all_case = len(r_index) * len(g_index) * len(b_index)
invalid_case = 0
for i in r_index:
for j in g_index:
s_i, s_j = sorted([i, j])
tmp_max_b = s_j + (s_j-s_i)
if tmp_max_b in b_index:
invalid_case += 1
tmp_min_b = s_i - (s_j-s_i)
if tmp_min_b in b_index:
invalid_case += 1
tmp_mid_b = (s_i + s_j) / 2
if tmp_mid_b in b_index:
invalid_case += 1
return all_case - invalid_case
if __name__ == '__main__':
raw_data = [val.rstrip() for val in stdin.readlines()]
data = [list(map(str, val.split(' '))) for val in raw_data]
result = get_result(data)
print(result)
| p02714 |
e=enumerate
_,s=open(0)
r,g,b=list(map(s.count,'RGB'))
print((r*g*b-sum(c!=d!=s[i-~j]!=c for i,c in e(s)for j,d in e(s[i+2:-1:2])))) | e=enumerate
_,s=open(0)
r,g,b=list(map(s.count,'RGB'))
print((r*g*b-sum(c!=d!=s[i+j]!=c for i,c in e(s)for j,d in e(s[i:-1:2])))) | p02714 |
import sys, math
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
res = 0
r = []
g = []
b = []
for i, c in enumerate(s):
if c == "R":
r.append(i)
if c == "G":
g.append(i)
if c == "B":
b.append(i)
res = len(r) * len(b) * len(g)
for i in r:
for j in g:
for k in b:
x,y,z = sorted([i,j,k])
if y-x ==z-y:
res -= 1
print(res) | import sys, math
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
res = 0
r = []
g = []
b = []
for i, c in enumerate(s):
if c == "R":
r.append(i)
if c == "G":
g.append(i)
if c == "B":
b.append(i)
res = len(r) * len(b) * len(g)
def bin_find(tar):
left = 0
right = len(b)
while left < right:
mid = (left+right) // 2
if b[mid] < tar:
left = mid+1
elif b[mid] > tar:
right = mid
else:
return mid
return -1
for i in r:
for j in g:
diff = i - j
if diff < 0:
diff = -diff
if diff % 2 == 0:
target = diff // 2 + min(i,j)
if target < n and s[target] == 'B':
res -= 1
target = min(i,j) - diff
if target >= 0 and s[target] == 'B':
res -= 1
target = max(i,j) + diff
if target < n and s[target] == "B":
res -= 1
print(res) | p02714 |
from time import time
def solve(N, S):
answer = 0
for i in range(N):
Si = S[i]
for k in range(i+2, N):
Sk = S[k]
if Si == Sk:
continue
for j in range(i+1, k):
if j-i == k-j:
continue
Sj = S[j]
if Si == Sj or Sj == Sk:
continue
answer += 1
print(answer)
def main(N, S):
import sys
start = time()
from itertools import combinations
Cs = [[], [], []]
for i in range(N):
c = S[i]
if c == 'R':
Cs[0].append(i)
elif c == 'G':
Cs[1].append(i)
elif c == 'B':
Cs[2].append(i)
answer = 0
for C in Cs:
a = 0
print(C, len(C))
for Ci in range(len(C)-1):
i = C[Ci]
for Cj in range(Ci+1, len(C)):
j = C[Cj]
print("*", i, j)
print(i) # i より前
print(j - i - 1) # i と j の間
print(N - 1 - j) # j より後
print(Ci)
print(Cj - Ci-1)
print(len(C) - 1 - Cj)
a += i # i より前
a += N - 1 - j # j より後
a += j - i - 1 # i と j の間
a -= Ci
a -= Cj - Ci-1
a -= len(C) - 1 - Cj
print(S[C[0]], "expect", sum(S[C[0]] in (i, j, k) and (i == j or j == k or i == k) for i,j,k in combinations(S, 3)))
print(S[C[0]], "actual", a)
answer += a
print("expect", sum(i == j or j == k or i == k for i,j,k in combinations(S, 3)))
print("actual", answer)
print(answer, time() - start, file=sys.stderr)
for i in range(N):
for d in range(1, N-i):
if i + 2*d < N and not(S[i] == S[i+d] or S[i] == S[i+2*d]):
answer += 1
total = N * (N-1)*(N-2) // 6
print(total, answer, file=sys.stderr)
print(total - answer)
print(time() - start, file=sys.stderr)
N = int(input())
S = input()
solve(N, S)
#main(N, S)
| from time import time
def solve(N, S):
answer = 0
Cs = [[], [], []]
for i in range(N):
c = S[i]
if c == 'R':
Cs[0].append(i)
elif c == 'G':
Cs[1].append(i)
elif c == 'B':
Cs[2].append(i)
answer = len(Cs[0]) * len(Cs[1]) * len(Cs[2])
for i in range(N):
for d in range(1, N-i):
if i + 2*d < N and not(S[i] == S[i+d] or S[i] == S[i+2*d] or S[i+d*2] == S[i+d]):
answer -= 1
print(answer)
def main(N, S):
import sys
start = time()
from itertools import combinations
Cs = [[], [], []]
for i in range(N):
c = S[i]
if c == 'R':
Cs[0].append(i)
elif c == 'G':
Cs[1].append(i)
elif c == 'B':
Cs[2].append(i)
answer = 0
for C in Cs:
a = 0
print(C, len(C))
for Ci in range(len(C)-1):
i = C[Ci]
for Cj in range(Ci+1, len(C)):
j = C[Cj]
print("*", i, j)
print(i) # i より前
print(j - i - 1) # i と j の間
print(N - 1 - j) # j より後
print(Ci)
print(Cj - Ci-1)
print(len(C) - 1 - Cj)
a += i # i より前
a += N - 1 - j # j より後
a += j - i - 1 # i と j の間
a -= Ci
a -= Cj - Ci-1
a -= len(C) - 1 - Cj
print(S[C[0]], "expect", sum(S[C[0]] in (i, j, k) and (i == j or j == k or i == k) for i,j,k in combinations(S, 3)))
print(S[C[0]], "actual", a)
answer += a
print("expect", sum(i == j or j == k or i == k for i,j,k in combinations(S, 3)))
print("actual", answer)
print(answer, time() - start, file=sys.stderr)
for i in range(N):
for d in range(1, N-i):
if i + 2*d < N and not(S[i] == S[i+d] or S[i] == S[i+2*d]):
answer += 1
total = N * (N-1)*(N-2) // 6
print(total, answer, file=sys.stderr)
print(total - answer)
print(time() - start, file=sys.stderr)
N = int(input())
S = input()
solve(N, S)
#main(N, S)
| p02714 |
import sys
import collections
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
s = str(readline().rstrip().decode('utf-8'))
c = collections.Counter(list(s))
left = collections.defaultdict(int)
cnt = 0
for i in range(n - 2):
left[s[i]] += 1
mid = collections.defaultdict(int)
for k, v in list(left.items()):
mid[k] += v
for j in range(i + 1, n - 1):
mid[s[j]] += 1
if s[i] != s[j]:
if [s[i], s[j]].count("R") == 0:
cnt += c["R"] - mid["R"]
if j + j - i < n:
if s[j+j-i] == "R":
cnt -= 1
elif [s[i], s[j]].count("G") == 0:
cnt += c["G"] - mid["G"]
if j + j - i < n:
if s[j+j-i] == "G":
cnt -= 1
elif [s[i], s[j]].count("B") == 0:
cnt += c["B"] - mid["B"]
if j + j - i < n:
if s[j+j-i] == "B":
cnt -= 1
print(cnt)
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
s = str(readline().rstrip().decode('utf-8'))
r = s.count("R")
g = s.count("G")
b = s.count("B")
cnt = r * g * b
for i in range(n - 2):
for j in range(i + 1, n - 1):
k = j + j - i
if k < n:
if s[i] != s[j] and s[j] != s[k] and s[i] != s[k]:
cnt -= 1
print(cnt)
if __name__ == '__main__':
solve()
| p02714 |
# abc162_d.py
import sys
import time
import unittest
from io import StringIO
import itertools
def resolve():
N = int(input())
S = input()
sum = 0
for i, j, k in itertools.combinations(range(N), 3):
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k] and j - i != k - j:
sum += 1
print(sum)
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def assertTLE(self, input):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
# def test_入力例_n(self):
# input = """9999992"""
# self.assertTLE(input)
def setUp(self):
self.startTime = time.time()
def tearDown(self):
t = time.time() - self.startTime
print('%s: %.3f' % (self.id(), t), flush=True)
def test_入力例_1(self):
input = """4
RRGB"""
output = """1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB"""
output = """1800"""
self.assertIO(input, output)
if __name__ == "__main__":
if "IS_LOCAL" in locals():
suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
unittest.TextTestRunner(verbosity=0).run(suite)
else:
resolve()
| # abc162_d.py
import sys
import time
import unittest
from io import StringIO
def resolve():
int(input())
S = input()
r = S.count("R")
g = S.count("G")
b = S.count("B")
sum = r * g * b
for i in range(len(S)):
for j in range(i + 1, len(S)):
k = j + (j - i)
if k < len(S) and S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
sum -= 1
print(sum)
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def checkTLE(self, input):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
def debugIO(self, input):
stdin = sys.stdin
sys.stdin = StringIO(input)
resolve()
sys.stdin = stdin
def setUp(self):
self.startTime = time.time()
def tearDown(self):
t = time.time() - self.startTime
print('%s: %.3f' % (self.id(), t), flush=True)
def test_入力例_1(self):
input = """4
RRGB"""
output = """1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB"""
output = """1800"""
self.assertIO(input, output)
if __name__ == "__main__":
if "IS_LOCAL" in locals():
suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
unittest.TextTestRunner(verbosity=0).run(suite)
else:
resolve()
| p02714 |
from sys import stdin, stdout
def main():
N=int(stdin.readline())
S=stdin.readline().rstrip()
R, G, B = [], [], []
for i, c in enumerate(S):
if c == 'R':
R.append(i)
elif c == 'G':
G.append(i)
else:
B.append(i)
cnt = 0
for ri in R:
for gi in G:
for bi in B:
if abs(gi-ri) != abs(bi-gi) and abs(ri-bi) != abs(bi-gi) and abs(ri-bi) != abs(ri-gi):
cnt+=1
stdout.write(str(cnt)+"\n")
main()
| from sys import stdin, stdout
def main():
N=int(stdin.readline())
S=stdin.readline().rstrip()
R, G, B = set(), set(), set()
for i, c in enumerate(S):
if c == 'R':
R.add(i)
elif c == 'G':
G.add(i)
else:
B.add(i)
cnt, total = 0, len(R) * len(G) * len(B)
for ri in R:
for gi in G:
if abs(ri-gi)+gi in B:
cnt += 1
if abs(ri-gi)+ri in B:
cnt += 1
for ri in G:
for gi in B:
if abs(ri-gi)+gi in R:
cnt += 1
if abs(ri-gi)+ri in R:
cnt += 1
for ri in R:
for gi in B:
if abs(ri-gi)+gi in G:
cnt += 1
if abs(ri-gi)+ri in G:
cnt += 1
stdout.write(str(total-cnt)+"\n")
main()
| p02714 |
import sys
N = int(sys.stdin.readline().rstrip())
S = sys.stdin.readline().rstrip()
if len(set(S)) == 1 or N < 3:
print((0))
sys.exit()
ans = []
for i in range(N - 2):
a = S[i]
for j in range(i + 1, N - 1):
b = S[j]
if a == b:
continue
jtoi = j - i
for k in range(j + 1, N):
c = S[k]
if a == c or b == c:
continue
ktoj = k - j
if jtoi != ktoj:
ans.append(None)
print((len(ans))) | import sys
N = int(sys.stdin.readline().rstrip())
S = sys.stdin.readline().rstrip()
if len(set(S)) == 1 or N < 3:
print((0))
sys.exit()
Rs = S.count("R")
Gs = S.count("G")
Bs = S.count("B")
ans = Rs * Gs * Bs
for i in range(N - 1):
for j in range(i + 1, N):
k = j + (j - i)
if k >= N: break
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
ans -= 1
print(ans) | p02714 |
#!/usr/bin/env pypy3
# n,m = map(int,sys.stdin.readline().split())
# a = list(map(int,sys.stdin.readline().split()))
# a = [sys.stdin.readline() for s in range(n)]
# s = sys.stdin.readline().rstrip()
# n = int(sys.stdin.readline())
# d = collections.defaultdict(list)
# import math
# from functools import reduce
import sys
sys.setrecursionlimit(15000)
n = int(sys.stdin.readline())
s = sys.stdin.readline().rstrip()
d = {"R":[],"G":[],"B":[]}
for i in range(n):
d[s[i]].append(i)
s = 0
s = sum(1 for a in d["R"] for b in d["G"] for c in d["B"] if abs(a-b) != abs(b-c) and abs(a-c) != abs(c-b) and abs(b-a) != abs(a-c))
print(s) | #!/usr/bin/env pypy3
# n,m = map(int,sys.stdin.readline().split())
# a = list(map(int,sys.stdin.readline().split()))
# a = [sys.stdin.readline() for s in range(n)]
# s = sys.stdin.readline().rstrip()
# n = int(sys.stdin.readline())
# d = collections.defaultdict(list)
# import math
# from functools import reduce
import sys
sys.setrecursionlimit(15000)
n = int(sys.stdin.readline())
s = sys.stdin.readline().rstrip()
d = {"R":[],"G":[],"B":[]}
sb = set()
for i in range(n):
d[s[i]].append(i)
if s[i]=="B":
sb.add(i)
s = 0
#s = sum(1 for a in d["R"] for b in d["G"] for c in d["B"] if abs(a-b) != abs(b-c) and abs(a-c) != abs(c-b) and abs(b-a) != abs(a-c))
#s = len(d["R"])*len(d["G"])*len(d["B"])-sum(1 for a in d["R"] for b in d["G"] for c in d["B"] if abs(a-b) == abs(b-c) or abs(a-c) == abs(c-b) or abs(b-a) == abs(a-c))
for a in d["R"]:
for b in d["G"]:
s += len(d["B"])
if 2*b-a in sb:
s -= 1
if 2*a-b in sb:
s -= 1
if (a+b)%2 == 0 and (a+b)//2 in sb:
s -= 1
print(s) | p02714 |
import sys
import math
from functools import reduce
# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")
def gcd_list(numbers):
return reduce(math.gcd, numbers)
N = II()
S = input()
ans = 0
for i in range(1, N-2):
for j in range(1+i, N):
#if j <= i:
# continue
for k in range(1+j, N+1):
#if k <= j:
# continue
if not(j-i == k-j or S[i-1] == S[j-1] or S[i-1] == S[k-1] or S[k-1] == S[j-1]):
ans+=1
print(ans)
| import sys
import math
from functools import reduce
# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")
def gcd_list(numbers):
return reduce(math.gcd, numbers)
N = int(input())
S = input()
ans = S.count("R") * S.count("G") * S.count("B")
for i in range(N-2):
for j in range(i+1,N-1):
k=2*j-i
if k>=N:
continue
if S[i]!=S[j] and S[j]!=S[k] and S[k]!=S[i]:
ans-=1
print(ans)
| p02714 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.