s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s769985001 | p03855 | u375870553 | 1573330169 | Python | Python (3.4.3) | py | Runtime Error | 831 | 25792 | 1300 | road_par = []
road_rank = []
rail_par = []
rail_rank = []
c1 = []
c2 = []
def init(par, rank, c, n):
for i in range(n):
par.append(i)
rank.append(0)
c.append(0)
def find(par,x):
if par[x] == x:
return x
par[x] = find(par, par[x])
return par[x]
def unite(par, rank, x, y):
x = par[x]; y = par[y]
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
elif rank[y] < rank[x]:
par[y] = x
else:
par[y] = x
rank[x] += 1
def same(par, x, y):
if find(par, x) == find(par, y):
return True
else:
return False
N, K, L = map(int, input().split())
init(road_par, road_rank, c1, N)
init(rail_par, rail_rank, c2, N)
for i in range(K):
f, t = map(int, input().split())
unite(road_par, road_rank, f-1, t-1)
for i in range(L):
f,t = map(int, input().split())
unite(rail_par, rail_rank, f-1, t-1)
for i in range(N):
c1[find(road_par, i)] += 1
c2[find(rail_par, i)] += 1
for i in range(N):
if c1[i] == 1:
road_par[i] = -1
if c2[i] == 1:
rail_par[i] = -1
ans = [0 for i in range(N)]
for i in range(N):
if road_par[i] != -1:
ans[i] +=1
if rail_par[i] != -1:
ans[i] += 1
for i in range(N):
print(ans[i]) |
s797191193 | p03855 | u937642029 | 1571950126 | Python | PyPy3 (2.4.0) | py | Runtime Error | 419 | 54000 | 1440 | def change(after,index,li):
before = li[index]
for i in range(len(li)):
if li[i]==before:
li[i]=after
def main():
n,k,l = map(int,input().split())
road=[0 for _ in range(n)]
train=[0 for _ in range(n)]
r=t=1
for _ in range(k):
p,q = map(int,input().split())
if road[p-1]==0 and road[q-1]==0:
road[p-1]=road[q-1]=r
r+=1
elif road[p-1]!=0 and road[q-1]==0:
change(r,p-1,road)
road[q-1]=r
r+=1
elif road[p-1]==0 and road[q-1]!=0:
change(r,q-1,road)
road[p-1]=r
r+=1
else:
change(r,p-1,*road)
change(r,q-1,*road)
r+=1
for _ in range(l):
p,q = map(int,input().split())
if train[p-1]==0 and train[q-1]==0:
train[p-1]=train[q-1]=t
t+=1
elif train[p-1]!=0 and train[q-1]==0:
change(t,p-1,train)
train[q-1]=t
t+=1
elif train[p-1]==0 and train[q-1]!=0:
change(t,q-1,train)
train[p-1]=t
t+=1
else:
change(t,p-1,train)
change(t,q-1,train)
t+=1
for i in range(n):
ans=1
for j in range(n):
if i!=j and train[i]!=0 and train[i]==train[j] and road[i]!=0 and road[i]==road[j]:
ans+=1
print(ans)
main()
|
s061702667 | p03855 | u893478938 | 1571440297 | Python | PyPy3 (2.4.0) | py | Runtime Error | 1252 | 75900 | 916 | N,K,L = map(int,input().split())
root_road = list(range(N))
root_rail = list(range(N))
depth_road = [1 for _ in range(N)]
depth_rail = [1 for _ in range(N)]
def find(a,root):
if root[a] == a:
return a
else:
root[a] = find(root[a],root)
return root[a]
def unite(a,b,root,depth):
A = find(a,root)
B = find(b,root)
if A == B:
return
elif depth[A] > depth[B]:
root[B] = A
depth[A] += depth[B]
else:
root[A] = B
depth[B] += depth[A]
for i in range(K):
p,q = map(int,input().split())
unite(p-1,q-1,root_road,depth_road)
for i in range(L):
r,s = map(int,input().split())
unite(r-1,s-1,root_rail,depth_rail)
d = defaultdict(int)
pairs = []
for i in range(N):
road = find(i,root_road)
rail = find(i,root_rail)
pairs.append((road,rail))
d[(road,rail)] += 1
for p in pairs:
print(d[p],end = " ") |
s306078380 | p03855 | u314050667 | 1571251682 | Python | Python (3.4.3) | py | Runtime Error | 570 | 23540 | 1536 | import sys
import collections as c
sys.setrecursionlimit(10**6)
import sys
sys.setrecursionlimit(10**7)
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x):
return -self.root[self.Find_Root(x)]
N, K, L = map(int,input().split())
p = []
q = []
l = []
r = []
for _ in range(K):
p_tmp, q_tmp = map(int ,input().split())
p.append(p_tmp)
q.append(q_tmp)
for _ in range(L):
l_tmp, r_tmp = map(int, input().split())
l.append(l_tmp)
r.append(r_tmp)
road = UnionFind(N)
train = UnionFind(N)
for i in range(K):
road.uniteTree(p[i], q[i])
for i in range(L):
train.uniteTree(l[i], r[i])
ar = []
for i in range(1,N+1):
a = road.findRoot(i)
b = train.findRoot(i)
ar.append(str([a,b]))
Car = c.Counter(ar)
for i in range(N):
print(Car[ar[i]], end = " ") |
s522821517 | p03855 | u314050667 | 1571249434 | Python | Python (3.4.3) | py | Runtime Error | 2128 | 640808 | 1392 | import sys
import collections as c
sys.setrecursionlimit(10**6)
class UnionFind():
def __init__(self, n):
self.size = n
self.root = [-1 for _ in range(n+1)]
self.rnk = [0 for _ in range(n+1)]
def findRoot(self, a):
if self.root[a] < 0:
return a
else:
return self.findRoot(self.root[a])
def uniteTree(self, a, b):
a = self.findRoot(a)
b = self.findRoot(b)
if a == b:
return
elif self.rnk[a] > self.rnk[b]:
self.root[a] += self.root[b]
self.root[b] = a
elif self.rnk[b] > self.rnk[a]:
self.root[b] += self.root[a]
self.root[a] = b
elif self.rnk[a] == self.rnk[b]:
self.root[b] += self.rnk[a]
self.root[a] = b
self.rnk[b] += 1
def judgeTree(self, a, b):
return self.findRoot(a) == self.findRoot(b)
def count(self, a):
return self.rnk[self.findRoot(a)] * (-1)
N, K, L = map(int,input().split())
p = []
q = []
l = []
r = []
for _ in range(K):
p_tmp, q_tmp = map(int ,input().split())
p.append(p_tmp)
q.append(q_tmp)
for _ in range(L):
l_tmp, r_tmp = map(int, input().split())
l.append(l_tmp)
r.append(r_tmp)
road = UnionFind(N)
train = UnionFind(N)
for i in range(K):
road.uniteTree(p[i], q[i])
for i in range(L):
train.uniteTree(l[i], r[i])
ar = []
for i in range(1,N+1):
a = road.findRoot(i)
b = train.findRoot(i)
ar.append(str([a,b]))
Car = c.Counter(ar)
for i in range(N):
print(Car[ar[i]], end = " ") |
s935716957 | p03855 | u314050667 | 1571249180 | Python | Python (3.4.3) | py | Runtime Error | 2161 | 640776 | 1405 | import sys
import collections as c
sys.setrecursionlimit(10**6)
class UnionFind():
def __init__(self, n):
self.size = n
self.root = [-1 for _ in range(n+1)]
self.rnk = [0 for _ in range(n+1)]
def findRoot(self, a):
if self.root[a] < 0:
return a
else:
return self.findRoot(self.root[a])
def uniteTree(self, a, b):
a = self.findRoot(a)
b = self.findRoot(b)
if a == b:
return
elif self.rnk[a] > self.rnk[b]:
self.root[a] += self.root[b]
self.root[b] = a
elif self.rnk[b] > self.rnk[a]:
self.root[b] += self.root[a]
self.root[a] = b
elif self.rnk[a] == self.rnk[b]:
self.root[b] += self.rnk[a]
self.root[a] = b
self.rnk[b] += 1
def judgeTree(self, a, b):
return self.findRoot(a) == self.findRoot(b)
def count(self, a):
return self.rnk[self.findRoot(a)] * (-1)
N, K, L = map(int,input().split())
p = []
q = []
l = []
r = []
for _ in range(K):
p_tmp, q_tmp = map(int ,input().split())
p.append(p_tmp)
q.append(q_tmp)
for _ in range(L):
l_tmp, r_tmp = map(int, input().split())
l.append(l_tmp)
r.append(r_tmp)
road = UnionFind(N)
train = UnionFind(N)
for i in range(K):
road.uniteTree(p[i], q[i])
for i in range(L):
train.uniteTree(l[i], r[i])
ar = ["[-1,-1]"]
for i in range(1,N+1):
a = road.findRoot(i)
b = train.findRoot(i)
ar.append(str([a,b]))
Car = c.Counter(ar)
for i in range(1,N+1):
print(Car[ar[i]], end = " ") |
s901846540 | p03855 | u314050667 | 1571232041 | Python | Python (3.4.3) | py | Runtime Error | 2150 | 640400 | 1417 | import sys
sys.setrecursionlimit(10**6)
class UnionFind():
def __init__(self, n):
self.size = n
self.root = [-1 for _ in range(n+1)]
self.rnk = [0 for _ in range(n+1)]
def findRoot(self, a):
if self.root[a] < 0:
return a
else:
return self.findRoot(self.root[a])
def uniteTree(self, a, b):
a = self.findRoot(a)
b = self.findRoot(b)
if a == b:
return
elif self.rnk[a] > self.rnk[b]:
self.root[a] += self.root[b]
self.root[b] = a
elif self.rnk[b] > self.rnk[a]:
self.root[b] += self.root[a]
self.root[a] = b
elif self.rnk[a] == self.rnk[b]:
self.root[b] += self.rnk[a]
self.root[a] = b
self.rnk[b] += 1
def judgeTree(self, a, b):
return self.findRoot(a) == self.findRoot(b)
def count(self, a):
return self.rnk[self.findRoot(a)] * (-1)
N, K, S = map(int, input().split())
P = []
Q = []
R = []
L = []
for _ in range(K):
p_tmp, q_tmp = map(int, input().split())
P.append(p_tmp)
Q.append(q_tmp)
for _ in range(S):
r_tmp, l_tmp = map(int, input().split())
R.append(r_tmp)
L.append(l_tmp)
road = UnionFind(N)
train = UnionFind(N)
for i in range(K):
road.uniteTree(P[i], Q[i])
for i in range(S):
train.uniteTree(R[i], L[i])
ans = [1 for _ in range(N)]
for i in range(1, N+1):
for j in range(1, N+1):
if i == j:
continue
else:
if road.judgeTree(i,j) and train.judgeTree(i,j):
ans[i-1] += 1
for i in ans:
print(i, end = " ") |
s728173610 | p03855 | u314050667 | 1571231880 | Python | Python (3.4.3) | py | Runtime Error | 2105 | 24100 | 1375 | class UnionFind():
def __init__(self, n):
self.size = n
self.root = [-1 for _ in range(n+1)]
self.rnk = [0 for _ in range(n+1)]
def findRoot(self, a):
if self.root[a] < 0:
return a
else:
return self.findRoot(self.root[a])
def uniteTree(self, a, b):
a = self.findRoot(a)
b = self.findRoot(b)
if a == b:
return
elif self.rnk[a] > self.rnk[b]:
self.root[a] += self.root[b]
self.root[b] = a
elif self.rnk[b] > self.rnk[a]:
self.root[b] += self.root[a]
self.root[a] = b
elif self.rnk[a] == self.rnk[b]:
self.root[b] += self.rnk[a]
self.root[a] = b
self.rnk[b] += 1
def judgeTree(self, a, b):
return self.findRoot(a) == self.findRoot(b)
def count(self, a):
return self.rnk[self.findRoot(a)] * (-1)
N, K, S = map(int, input().split())
P = []
Q = []
R = []
L = []
for _ in range(K):
p_tmp, q_tmp = map(int, input().split())
P.append(p_tmp)
Q.append(q_tmp)
for _ in range(S):
r_tmp, l_tmp = map(int, input().split())
R.append(r_tmp)
L.append(l_tmp)
road = UnionFind(N)
train = UnionFind(N)
for i in range(K):
road.uniteTree(P[i], Q[i])
for i in range(S):
train.uniteTree(R[i], L[i])
ans = [1 for _ in range(N)]
for i in range(1, N+1):
for j in range(1, N+1):
if i == j:
continue
else:
if road.judgeTree(i,j) and train.judgeTree(i,j):
ans[i-1] += 1
for i in ans:
print(i, end = " ") |
s888668968 | p03855 | u047816928 | 1570742715 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 896 | class UF:
def __init__(self, N):
self.uf = [-1]*N
self.n = N
def find(self, x):
if self.uf[x]<0: return x
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def size(self, x):
return -self.uf[self.find(x)]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x==y: return
if self.size(x) > self.size(y): x, y = y, x
self.uf[y] += self.uf[x]
self.uf[x] = y
self.n -= 1
N, K, L = list(map(int, input().split()))
uf1, uf2 = UF(N), UF(N)
for _ in range(K):
p, q = list(map(int, input().split()))
uf1.union(p-1, q-1)
for _ in range(L):
r, s = list(map(int, input().split()))
uf2.union(r-1, s-1)
keys = [(uf1.find(x), uf2.find(x)) for x in range(N)]
count = {}
for key in keys:
if key in count: count[key]+=1
else: count[key]=1
print(*[count[key] for key in keys]) |
s030248582 | p03855 | u047816928 | 1570739394 | Python | Python (3.4.3) | py | Runtime Error | 179 | 14532 | 791 | import sys
sys.setrecursionlimit(10000)
class UF:
def __init__(self, N):
self.uf = [-1]*N
def find(self, x):
if self.uf[x]<0: return x
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def size(self, x):
return -self.uf[self.find(x)]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if self.size(x) > self.size(y): x, y = y, x
self.uf[y] += self.uf[x]
self.uf[x] = y
N, K, L = list(map(int, input().split()))
uf1, uf2 = UF(N), UF(N)
for _ in range(K):
p, q = list(map(int, input().split()))
uf1.union(p-1, q-1)
for _ in range(L):
r, s = list(map(int, input().split()))
if uf1.find(r-1)==uf1.find(s-1):
uf2.union(r-1, s-1)
print(*[uf2.size(x) for x in range(N)]) |
s910662034 | p03855 | u047816928 | 1570738865 | Python | Python (3.4.3) | py | Runtime Error | 157 | 7008 | 750 | class UF:
def __init__(self, N):
self.uf = [-1]*N
def find(self, x):
if self.uf[x]<0: return x
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def size(self, x):
return -self.uf[self.find(x)]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if self.size(x) > self.size(y): x, y = y, x
self.uf[y] += self.uf[x]
self.uf[x] = y
N, K, L = list(map(int, input().split()))
uf1, uf2 = UF(N), UF(N)
for _ in range(K):
p, q = list(map(int, input().split()))
uf1.union(p-1, q-1)
for _ in range(L):
r, s = list(map(int, input().split()))
if uf1.find(r-1)==uf1.find(s-1):
uf2.union(r-1, s-1)
print(*[uf2.size(x) for x in range(N)]) |
s144024186 | p03855 | u047816928 | 1570738776 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 694 | class UF:
def __init__(self, N):
self.uf = [-1]*N
def find(self, x):
if self.uf[x]<0: return x
self.uf[x] = self.find(self.uf[x])
return self.uf[x]
def size(self, x):
return -self.uf[self.find(x)]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if self.size(x) > self.size(y): x, y = y, x
self.uf[y] += self.uf[x]
self.uf[x] = y
N, K, L = list(map(int, input().split()))
uf1, uf2 = UF(N), UF(N)
for _ in range(K):
p, q = list(map(int, input().split()))
uf1.union(p-1, q-1)
for _ in range(L):
r, s = list(map(int, input().split()))
if uf1.find(r-1)==uf1.find(s-1):
uf2.union(r-1, s-1)
print(*[uf2.size(x) for x in range(N)]) |
s633915916 | p03855 | u842689614 | 1567011892 | Python | Python (3.4.3) | py | Runtime Error | 1647 | 106120 | 2103 | #import sys
#input=sys.stdin.readline
N,K,L=map(int,input().split())
pq=[list(map(int,input().split())) for _ in range(K)]
rs=[list(map(int,input().split())) for _ in range(L)]
city_road=set()
city_train=set()
city_road_train=set()
city_roadgroup_dict={}
roadgroup_city_dict={}
city_traingroup_dict={}
traingroup_city_dict={}
for ch_pq in pq:
for pq_i in range(2):
if not ch_pq[pq_i] in city_road:
city_road.add(ch_pq[pq_i])
if not ch_pq[0] in city_roadgroup_dict:
if not ch_pq[1] in city_roadgroup_dict:
city_roadgroup_dict[ch_pq[0]]=len(roadgroup_city_dict)
city_roadgroup_dict[ch_pq[1]]=len(roadgroup_city_dict)
roadgroup_city_dict[len(roadgroup_city_dict)]=set([ch_pq[0],ch_pq[1]])
else:
city_roadgroup_dict[ch_pq[0]]=city_roadgroup_dict[ch_pq[1]]
roadgroup_city_dict[city_roadgroup_dict[ch_pq[1]]].add(ch_pq[0])
elif not ch_pq[1] in city_roadgroup_dict:
city_roadgroup_dict[ch_pq[1]]=city_roadgroup_dict[ch_pq[0]]
roadgroup_city_dict[city_roadgroup_dict[ch_pq[0]]].add(ch_pq[1])
for ch_rs in rs:
for rs_i in range(2):
if not ch_rs[rs_i] in city_road_train and ch_rs[rs_i] in city_road:
city_road_train.add(ch_rs[rs_i])
if not ch_rs[0] in city_traingroup_dict:
if not ch_rs[1] in city_traingroup_dict:
city_traingroup_dict[ch_rs[0]]=len(traingroup_city_dict)
city_traingroup_dict[ch_rs[1]]=len(traingroup_city_dict)
traingroup_city_dict[len(traingroup_city_dict)]=set([ch_rs[0],ch_rs[1]])
else:
city_traingroup_dict[ch_rs[0]]=city_traingroup_dict[ch_rs[1]]
traingroup_city_dict[city_traingroup_dict[ch_rs[1]]].add(ch_rs[0])
elif not ch_rs[1] in city_traingroup_dict:
city_traingroup_dict[ch_rs[1]]=city_traingroup_dict[ch_rs[0]]
traingroup_city_dict[city_traingroup_dict[ch_rs[0]]].add(ch_rs[1])
city_both_conn_num=['1']*N
for ch_city in list(city_road_train):
group_n=city_traingroup_dict[ch_city]
city_both_conn_num[ch_city-1]=str(len(roadgroup_city_dict[group_n] \
& traingroup_city_dict[group_n]))
print(' '.join(city_both_conn_num))
|
s868681790 | p03855 | u842689614 | 1567011804 | Python | Python (3.4.3) | py | Runtime Error | 1377 | 106092 | 2101 | import sys
input=sys.stdin.readline
N,K,L=map(int,input().split())
pq=[list(map(int,input().split())) for _ in range(K)]
rs=[list(map(int,input().split())) for _ in range(L)]
city_road=set()
city_train=set()
city_road_train=set()
city_roadgroup_dict={}
roadgroup_city_dict={}
city_traingroup_dict={}
traingroup_city_dict={}
for ch_pq in pq:
for pq_i in range(2):
if not ch_pq[pq_i] in city_road:
city_road.add(ch_pq[pq_i])
if not ch_pq[0] in city_roadgroup_dict:
if not ch_pq[1] in city_roadgroup_dict:
city_roadgroup_dict[ch_pq[0]]=len(roadgroup_city_dict)
city_roadgroup_dict[ch_pq[1]]=len(roadgroup_city_dict)
roadgroup_city_dict[len(roadgroup_city_dict)]=set([ch_pq[0],ch_pq[1]])
else:
city_roadgroup_dict[ch_pq[0]]=city_roadgroup_dict[ch_pq[1]]
roadgroup_city_dict[city_roadgroup_dict[ch_pq[1]]].add(ch_pq[0])
elif not ch_pq[1] in city_roadgroup_dict:
city_roadgroup_dict[ch_pq[1]]=city_roadgroup_dict[ch_pq[0]]
roadgroup_city_dict[city_roadgroup_dict[ch_pq[0]]].add(ch_pq[1])
for ch_rs in rs:
for rs_i in range(2):
if not ch_rs[rs_i] in city_road_train and ch_rs[rs_i] in city_road:
city_road_train.add(ch_rs[rs_i])
if not ch_rs[0] in city_traingroup_dict:
if not ch_rs[1] in city_traingroup_dict:
city_traingroup_dict[ch_rs[0]]=len(traingroup_city_dict)
city_traingroup_dict[ch_rs[1]]=len(traingroup_city_dict)
traingroup_city_dict[len(traingroup_city_dict)]=set([ch_rs[0],ch_rs[1]])
else:
city_traingroup_dict[ch_rs[0]]=city_traingroup_dict[ch_rs[1]]
traingroup_city_dict[city_traingroup_dict[ch_rs[1]]].add(ch_rs[0])
elif not ch_rs[1] in city_traingroup_dict:
city_traingroup_dict[ch_rs[1]]=city_traingroup_dict[ch_rs[0]]
traingroup_city_dict[city_traingroup_dict[ch_rs[0]]].add(ch_rs[1])
city_both_conn_num=['1']*N
for ch_city in list(city_road_train):
group_n=city_traingroup_dict[ch_city]
city_both_conn_num[ch_city-1]=str(len(roadgroup_city_dict[group_n] \
& traingroup_city_dict[group_n]))
print(' '.join(city_both_conn_num))
|
s597556293 | p03855 | u347640436 | 1566662720 | Python | Python (3.4.3) | py | Runtime Error | 58 | 17200 | 815 | def create_links(n, k):
links = [[] for _ in range(n)]
for i in range(k):
p, q = map(int, readline().split())
links[p - 1].append(q - 1)
links[q - 1].append(p - 1)
return links
def create_groups(n, links):
groups = list(range(n))
for i in range(n):
if groups[i] != i:
continue
q = [i]
while q:
j = q.pop()
for k in links[j]:
if groups[k] != i:
groups[k] = i
q.append(k)
n, k, l = map(int, input().split())
road_links = create_links(n, k)
rail_links = create_links(n, l)
road_groups = create_groups(n, road_links)
rail_groups = create_groups(n, rail_links)
d = {}
for i in range(n):
t = (road_groups[i], rail_groups[i])
if t in d:
d[t] += 1
else:
d[t] = 1
print(*[d[(road_groups[i], rail_groups[i])] for i in range(n)])
|
s550074846 | p03855 | u347640436 | 1566657107 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 824 | from sys import stdin
def main():
def find(parent, i):
t = parent[i]
if t == -1:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[i] = j
from builtins import int, map, range
readline = stdin.readline()
n, k, l = map(int, readline().split())
roads = [-1] * n
rails = [-1] * n
for i in range(k):
p, q = map(int, readline().split())
unite(roads, p - 1, q - 1)
for i in range(l):
p, q = map(int, readline().split())
unite(rails, p - 1, q - 1)
d = {}
for i in range(n):
t = (find(roads, i), find(rails, i))
if t in d:
d[t] += 1
else:
d[t] = 1
print(*[d[(find(roads, i), find(rails, i))] for i in range(n)])
main()
|
s065249037 | p03855 | u347640436 | 1566650859 | Python | Python (3.4.3) | py | Runtime Error | 2113 | 152596 | 1215 | from collections import deque
from sys import stdin
def create_groups(n, links):
from builtins import len, set
groups = [-1 for _ in range(n)]
group_number = 0
d = deque()
for i in range(n):
if groups[i] == -1:
group_member = []
d.append(i)
while len(d) != 0:
j = d.popleft()
groups[j] = group_number
group_member.append(j)
for k in links[j]:
if groups[k] == -1:
d.append(k)
group_number += 1
return groups
def read_links(n, k):
from builtins import int, map
readline = stdin.readline
links = [[] for _ in range(n)]
for i in range(k):
p, q = map(int, readline().split())
links[p - 1].append(q - 1)
links[q - 1].append(p - 1)
return links
def main():
from builtins import len
n, k, l = map(int, input().split())
road_links = read_links(n, k)
train_links = read_links(n, l)
road_groups = create_groups(n, road_links)
train_groups = create_groups(n, train_links)
result = {}
for i in range(n):
t = (road_groups[i], train_groups[i])
if t in result:
result[t] += 1
else:
result[t] +=1
print(*[result[(road_groups[i], train_groups[i])] for i in range(n)])
main()
|
s224231143 | p03855 | u186838327 | 1566623447 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38384 | 1107 | mport sys
input = sys.stdin.readline
def Find(x, par):
if par[x] < 0:
return x
else:
# 経路圧縮
par[x] = Find(par[x], par)
return par[x]
def Unite(x, y, par, rank):
x = Find(x, par)
y = Find(y, par)
if x != y:
# rankの低い方を高い方につなげる
if rank[x] < rank[y]:
par[y] += par[x]
par[x] = y
else:
par[x] += par[y]
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
def Same(x, y, par):
return Find(x, par) == Find(y, par)
def Size(x, par):
return -par[Find(x)]
n, k, l = map(int, input().split())
rpar = [-1]* n
tpar = [-1]* n
rrank = [0]*n
trank = [0]*n
for i in range(k):
p, q = map(int, input().split())
p, q =p-1, q-1
Unite(p,q, rpar, rrank)
for i_ in range(l):
p, q = map(int, input().split())
p, q =p-1, q-1
Unite(p,q, tpar, trank)
d = {}
IDs = [0]*n
for j in range(n):
ID = Find(j, rpar)+(Find(j, tpar)+1)*10**8
IDs[j] = ID
if ID in d:
d[ID] += 1
else:
d[ID] = 1
ans = ''
for j_ in range(n):
if j_ != 0:
ans += ' '
ans += str(d[IDs[j_]])
print(ans) |
s335794691 | p03855 | u353241315 | 1565909163 | Python | Python (3.4.3) | py | Runtime Error | 2108 | 76040 | 1446 | def find_root(edges, root, group, before, now):
group.append(now)
children = edges[now]
for child in children:
if child != before and child not in group:
root, group = find_root(edges, root, group, now, child)
return root, group
if __name__ == '__main__':
N, K, L = map(int, input().split())
roads = [[] for _ in range(N)]
rails = [[] for _ in range(N)]
road_roots = [None]*N
rail_roots = [None]*N
answer = [1]*N
for i in range(K):
p, q = map(int, input().split())
p -= 1
q -= 1
roads[p].append(q)
roads[q].append(p)
for i in range(L):
r, s = map(int, input().split())
r -= 1
s -= 1
rails[r].append(s)
rails[s].append(r)
for i, r in enumerate(road_roots):
if r is None:
root, group = find_root(roads, i, [], -1, i)
for g in group:
road_roots[g] = root
for i, r in enumerate(rail_roots):
if r is None:
root, group = find_root(rails, i, [], -1, i)
for g in group:
rail_roots[g] = root
railroads=[[rail, road] for rail, road in zip(road_roots, rail_roots)]
for n in range(N):
for d in range(1, N-n):
if railroads[n] == railroads[n+d]:
answer[n] += 1
answer[n+d] += 1
print(' '.join(list(map(str, answer)))) |
s209303782 | p03855 | u353241315 | 1565902092 | Python | Python (3.4.3) | py | Runtime Error | 1618 | 169988 | 1366 | if __name__ == '__main__':
N, K, L = map(int, input().split())
PQ = [None]*K
RS = [None]*L
roads = [set() for _ in range(N)]
rails = [set() for _ in range(N)]
answer = [None]*N
for i in range(K):
PQ[i] = list(map(int, input().split()))
#PQ = sorted(PQ, key=min)
for i in range(K):
if not roads[PQ[i][1] - 1]:
roads[PQ[i][0] - 1].add(PQ[i][0] - 1)
roads[PQ[i][0] - 1].add(PQ[i][1] - 1)
roads[PQ[i][1] - 1] = roads[PQ[i][0] - 1]
else:
roads[PQ[i][1] - 1].add(PQ[i][0] - 1)
roads[PQ[i][1] - 1].add(PQ[i][1] - 1)
roads[PQ[i][0] - 1] = roads[PQ[i][1] - 1]
for i in range(L):
RS[i] = list(map(int, input().split()))
#RS = sorted(RS, key=min)
for i in range(L):
if not rails[PQ[i][1] - 1]:
rails[RS[i][0] - 1].add(RS[i][0] - 1)
rails[RS[i][0] - 1].add(RS[i][1] - 1)
rails[RS[i][1] - 1] = rails[RS[i][0] - 1]
else:
rails[RS[i][1] - 1].add(RS[i][0] - 1)
rails[RS[i][1] - 1].add(RS[i][1] - 1)
rails[RS[i][0] - 1] = rails[RS[i][1] - 1]
for n in range(N):
roads[n].add(n)
rails[n].add(n)
answer[n]= len(roads[n] & rails[n])
print(' '.join(map(str, answer))) |
s745149806 | p03855 | u227082700 | 1565835261 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 35292 | 365 | from collections import*
n,k,l=map(int,input().split());d=[-1]*n;t=[-1]*n;M=lambda:map(int,input().split())
def f(l,x):return x if l[x]<0else f(l,l[x])
def u(l,x,y):
if f(l,x)!=f(l,y):l[f(l,y)]=f(l,x)
for _ in range(k):a,b=M();u(d,a-1,b-1)
for _ in range(l):a,b=M();u(t,a-1,b-1)
p=[(f(d,i),f(t,i))for i in range(n)];c=Counter(p);print(*[c[p[i]]for i in range(n)]) |
s683306608 | p03855 | u227082700 | 1565834922 | Python | Python (3.4.3) | py | Runtime Error | 140 | 7352 | 375 | from collections import*
n,k,l=map(int,input().split());d=[-1]*n;t=[-1]*n
def f(l,x):
if l[x]<0:return x
else:l[x]=f(l,l[x]);return l[x]
def u(l,x,y):l[f(l,y)]=f(l,x)
for _ in range(k):a,b=map(int,input().split());u(d,a-1,b-1)
for _ in range(l):a,b=map(int,input().split());u(t,a-1,b-1)
p=[(f(d,i),f(t,i))for i in range(n)];c=Counter(p);print(*[c[p[i]]for i in range(n)]) |
s243418291 | p03855 | u399721252 | 1563252820 | Python | PyPy3 (2.4.0) | py | Runtime Error | 1051 | 110412 | 939 | import sys
input = sys.stdin.readline
n, k, l = [ int(v) for v in input().split() ]
road_parent = [ i for i in range(n) ]
rail_parent = [ i for i in range(n) ]
def parent(x,a,inlist):
if inlist[x] == x:
return x, a
else:
return parent(inlist[x],a+1,inlist)
def union(z,inlist):
x, y = z[0], z[1]
inlist[x], rank_x = parent(x,0,inlist)
inlist[y], rank_y = parent(y,0,inlist)
if inlist[x] != inlist[y]:
if rank_x > rank_y:
inlist[inlist[y]] = inlist[x]
else:
inlist[inlist[x]] = inlist[y]
return
for i in range(n):
road = [ int(v)-1 for v in input().split() ]
union(road,road_parent)
for i in rail_list:
rail = [ int(v)-1 for v in input().split() ]
union(rail,rail_parent)
road_parent = [ parent(i,0,road_parent)[0] for i in range(n) ]
rail_parent = [ parent(i,0,rail_parent)[0] for i in range(n) ]
print(road_parent)
print(rail_parent) |
s755709676 | p03855 | u133886644 | 1562823107 | Python | Python (3.4.3) | py | Runtime Error | 2121 | 278848 | 1207 | import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.data = [0] * N
self.dd = [{i} for i in range(N)]
for i in range(N):
self.data[i] = i
def get_root(self, x):
r = self.data[x]
if r == x:
return r
p = self.get_root(r)
self.data[x] = p
self.dd[x].add(p)
self.dd[p].add(x)
return p
def unite(self, x, y):
rx = self.get_root(x)
ry = self.get_root(y)
if rx != ry:
self.data[rx] = ry
self.dd[x].add(y)
self.dd[y].add(x)
def same(self, x, y):
return self.get_root(x) == self.get_root(y)
N, K, L = map(int, input().split())
LA = [[int(v) - 1 for v in input().split()] for _ in range(K)]
LB = [[int(v) - 1 for v in input().split()] for _ in range(K)]
u1 = UnionFind(N)
for x, y in LA:
u1.unite(x, y)
u2 = UnionFind(N)
for x, y in LB:
u2.unite(x, y)
result = [0] * N
for i in range(N):
a = u1.get_root(i)
b = u2.get_root(i)
result[i] = len(u1.dd[a] & u2.dd[b])
print(" ".join(map(str, result)))
|
s585686963 | p03855 | u133886644 | 1562822858 | Python | Python (3.4.3) | py | Runtime Error | 2221 | 1813764 | 1239 | import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.data = [0] * N
self.dd = [{i} for i in range(N)]
for i in range(N):
self.data[i] = i
def get_root(self, x):
r = self.data[x]
if r == x:
return r
p = self.get_root(r)
self.data[x] = p
return p
def unite(self, x, y):
rx = self.get_root(x)
ry = self.get_root(y)
if rx != ry:
self.data[rx] = ry
self.dd[ry] = self.dd[x] | self.dd[ry]
self.dd[ry] = self.dd[y] | self.dd[ry]
self.dd[ry] = self.dd[rx] | self.dd[ry]
def same(self, x, y):
return self.get_root(x) == self.get_root(y)
N, K, L = map(int, input().split())
LA = [[int(v) - 1 for v in input().split()] for _ in range(K)]
LB = [[int(v) - 1 for v in input().split()] for _ in range(K)]
u1 = UnionFind(N)
for x, y in LA:
u1.unite(x, y)
u2 = UnionFind(N)
for x, y in LB:
u2.unite(x, y)
result = [0] * N
for i in range(N):
a = u1.get_root(i)
b = u2.get_root(i)
result[i] = len(u1.dd[a] & u2.dd[b])
print(" ".join(map(str, result))) |
s382001649 | p03855 | u969190727 | 1560659163 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38416 | 1168 | input = sys.stdin.readline
n,k,l=map(int,input().split())
parD,parT=[-1]*n,[-1]*n
def findD(x):
if parD[x]<0:
return x
else:
parD[x]=findD(parD[x])
return parD[x]
def uniteD(x,y):
x=findD(x)
y=findD(y)
if x==y:
return False
else:
if parD[x]>parD[y]:
x,y=y,x
parD[x]+=parD[y]
parD[y]=x
return True
def sameD(x,y):
return findD(x)==findD(y)
def sizeD(x):
return -parD[findD(x)]
def findT(x):
if parT[x]<0:
return x
else:
parT[x]=findT(parT[x])
return parT[x]
def uniteT(x,y):
x=findT(x)
y=findT(y)
if x==y:
return False
else:
if parT[x]>parT[y]:
x,y=y,x
parT[x]+=parT[y]
parT[y]=x
return True
def sameT(x,y):
return findT(x)==findT(y)
def sizeD(x):
return -parT[findT(x)]
for i in range(k):
p,q=map(int,input().split())
uniteD(p-1,q-1)
for i in range(l):
r,s=map(int,input().split())
uniteT(r-1,s-1)
for i in range(n):
findD(i)
findT(i)
C=[]
for i in range(n):
if parD[i]<0:
parD[i]=i
if parT[i]<0:
parT[i]=i
Ans=[]
for i in range(n):
Ans.append((parD[i],parT[i]))
ANS=collections.Counter(Ans)
for i in range(n):
print(ANS[Ans[i]]) |
s876748673 | p03855 | u978494963 | 1560036193 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 43696 | 878 | import copy
class UnionFind:
def __init__(self, N):
self._parent = [i for i in range(N)]
def find(self, x):
if self._parent[x] == x:
return x
else:
return self.find(self._parent[x])
def unite(self, a, b):
ta = self.find(a)
tb = self.find(b)
if(ta == tb):
return
self._parent[ta] = tb # make b as a parent of a
def check(self, a, b):
return self.find(a) == self.find(b)
if __name__ == '__main__':
N,K,L = map(int, input().split())
uf1 = UnionFind(N)
for _ in range(K):
p,q = map(int, input().split())
uf1.unite(p-1,q-1)
uf2 = UnionFind(N)
for _ in range(L):
s,r = map(int, input().split())
uf2.unite(s-1,r-1)
from collections import defaultdict
d = defaultdict(int)
for i in range(N):
d[(uf1.find(i), uf2.find(i))] += 1
ans = []
for i in range(N):
ans.append( str(d[(uf1.find(i), uf2.find(i))]) )
print(' '.join(ans)) |
s839466942 | p03855 | u978494963 | 1560033837 | Python | PyPy3 (2.4.0) | py | Runtime Error | 170 | 38384 | 881 | import copy
class UnionFind:
def __init__(self, N):
self._parent = [i for i in range(N)]
self._rank = [1 for i in range(N)]
def find(self, x):
if self._parent[x] == x:
return x
else:
return self.find(self._parent[x])
def unite(self, a, b):
ta = self.find(a)
tb = self.find(b)
if(ta == tb):
return
if self._rank[ta] < self._rank[tb]:
self._parent[ta] = tb # make b as a parent of a
else:
self._parent[tb] = ta # make a as a parent of b
if(ta == tb) rank[ta] += 1
def check(self, a, b):
return self.find(a) == self.find(b)
if __name__ == '__main__':
N,K,L = map(int, input().split())
ans = [1 for _ in range(N+1)]
uf = UnionFind(N+1)
for _ in range(K):
p,q = map(int, input().split())
uf.unite(p,q)
for _ in range(L):
s,r = map(int, input().split())
if uf.check(s,r):
ans[s] += 1
ans[r] += 1
print(*ans[1::]) |
s129381408 | p03855 | u365364616 | 1558643882 | Python | Python (3.4.3) | py | Runtime Error | 2106 | 54664 | 1022 | from collections import defaultdict
def dfs(i, V, E, num):
V[i] = num
for j in E[i]:
if V[j] > 0:
continue
V = dfs(j, V, E, num)
return V
n, k, l = map(int, input().split())
Er = defaultdict(list)
for i in range(k):
p, q = map(int, input().split())
Er[p].append(q)
Er[q].append(p)
Et = defaultdict(list)
for i in range(l):
r, s = map(int, input().split())
Et[r].append(s)
Et[s].append(r)
Vr_group = [None]
Vr = [0 for _ in range(n + 1)]
j = 1
for i in range(1, n + 1):
if Vr[i] > 0:
continue
Vr = dfs(i, Vr, Er, j)
Vr_group.append({t for t in range(1, n + 1) if Vr[t] == j})
j += 1
Vt_group = [None]
Vt = [0 for _ in range(n + 1)]
j = 1
for i in range(1, n + 1):
if Vt[i] > 0:
continue
Vt = dfs(i, Vt, Et, j)
Vt_group.append({t for t in range(1, n + 1) if Vt[t] == j})
j += 1
ans = []
for i in range(1, n + 1):
ans.append(len(Vr_group[Vr[i]] & Vt_group[Vt[i]]))
print(' '.join([str(x) for x in ans]))
|
s534702409 | p03855 | u238510421 | 1557364334 | Python | PyPy3 (2.4.0) | py | Runtime Error | 967 | 81240 | 2176 | from collections import Counter
N,K,L = map(int, input().split())
pq_list = []
for _ in range(K):
pq_list.append(list(map(int, input().split())))
rs_list = []
for _ in range(L):
rs_list.append(list(map(int, input().split())))
class UnionFind():
def __init__(self):
self.roots = {}
self.ranks = {}
def connect(self,x,y):
root_x = self.pick_root(x)
root_y = self.pick_root(y)
roots[x] = root_x
roots[y] = root_y
if not root_x == root_y:
if self.ranks[root_x] >= self.ranks[root_y]:
# 短い方の根を長い方の根にする
# 等しいときはxにくっつける
self.roots[y] = root_x
else:
self.roots[x] = root_y
if self.ranks[root_x]==self.ranks[root_y]:
# 等しいときxにくっつけると、xのランクが1増える
self.ranks[x] += 1
def pick_root(self,k):
if not k in self.roots:
self.roots[k] = k
self.ranks[k] = 1
return k
k_root = self.roots[k]
if k_root == k:
return k
else:
# 経路圧縮（のつもり）
# pick_rootで毎回見に行くのが無駄にも思えるが、いつ根ノードがくっつくかわからないので必要な気がしている
# self.roots[k] = self.pick_root(self.roots[k_root])
# return self.roots[k]
return self.pick_root(k_root)
UF_pq = UnionFind()
for p,q in pq_list:
UF_pq.connect(p, q)
UF_rs = UnionFind()
for r,s in rs_list:
UF_rs.connect(r, s)
root_tuples = []
for i in range(1,N+1):
if not i in UF_pq.roots:
root_tuples.append((None,None))
continue
if not i in UF_rs.roots:
root_tuples.append((None,None))
continue
pq_root = UF_pq.roots[i]
rs_root = UF_rs.roots[i]
root_tuples.append((pq_root,rs_root))
counter = Counter(root_tuples)
counter[(None,None)] = 1
kotae_list = []
for i in range(N):
kotae_list.append(counter[root_tuples[i]])
print(" ".join(map(str,kotae_list))) |
s687081231 | p03855 | u319818856 | 1554621830 | Python | Python (3.4.3) | py | Runtime Error | 1255 | 64380 | 1466 | class UnionFind:
def __init__(self, size: int):
self.__size = size
self.__root = [-1] * size
def root(self, x: int)->int:
if self.__root[x] < 0:
return x
self.__root[x] = self.root(self.__root[x])
return self.__root[x]
def size(self, x: int)->int:
root = self.root(x)
return self.__root[root]
def same(self, x: int, y: int)->bool:
return self.root(x) == self.root(y)
def unite(self, x: int, y: int):
rx, ry = self.root(x), self.root(y)
if rx == ry:
return
if ry < rx:
rx, ry = ry, rx
self.__root[rx] += self.__root[ry]
self.__root[ry] = rx
def connectivity(N: int, K: int, L: int, roads: list, rails: list)->list:
road_uf, rail_uf = UnionFind(N), UnionFind(N)
for p, q in roads:
road_uf.unite(p-1, q-1)
for r, s in rails:
rail_uf.unite(r-1, s-1)
freq = {}
for i in range(N):
p = (road_uf.root(i), rail_uf.root(i))
freq.setdefault(p, 0)
freq[p] += 1
return [freq[(road_uf.root(i), rail_uf.root(i))] for i in range(N)]
if __name__ == "__main__":
K = 0
L = 0
N, K, L = map(int, input().split())
roads = [tuple(int(s) for s in input().split()) for _ in range(K)]
rails = [tuple(int(s) for s in input().split()) for _ in range(K)]
ans = connectivity(N, K, L, roads, rails)
print(' '.join(map(str, ans)))
|
s807766071 | p03855 | u983918956 | 1554479424 | Python | Python (3.4.3) | py | Runtime Error | 607 | 57272 | 1353 | import sys
input = sys.stdin.readline
class Unionfind:
__slots__ = ['nodes','size']
def __init__(self, n):
self.nodes = list(range(n))
self.size = [1]*n
def root(self, x):
if self.nodes[x] == x:
return x
else:
root_x = self.root(self.nodes[x])
self.nodes[x] = root_x
return root_x
def unite(self, x, y):
x = self.root(x); y = self.root(y)
if x == y:
return
if self.size[x] < self.size[y]:
x, y = y, x
self.size[x] += self.size[y]
self.nodes[y] = x
def same(self, x, y):
return self.root(x) == self.root(y)
N,K,L = map(int,input().split())
road = [[int(e)-1 for e in input().split()] for _ in range(K)]
rail = [[int(e)-1 for e in input().split()] for _ in range(L)]
uf1 = Unionfind(N)
uf2 = Unionfind(N)
for p,q in road:
uf1.unite(p,q)
for r,s in rail:
uf2.unite(r,s)
set1 = [0]*N
set2 = [0]*N
for node in range(N):
if node == uf1.root(node):
set1[node] = set()
set1[node] = set1[uf1.root(node)]
set1[node].add(node)
if node == uf2.root(node):
set2[node] = set()
set2[node] = set2[uf2.root(node)]
set2[node].add(node)
ans = []
for node in range(N):
ans.append(str(len(set1[node] & set2[node])))
print(" ".join(ans)) |
s860593415 | p03855 | u619819312 | 1553352946 | Python | Python (3.4.3) | py | Runtime Error | 110 | 19896 | 598 | def root(x,d):
if d[x]!=x:
d[x]=root(x,d)
return d[x]
def unite(x,y,h):
x=root(x,h)
y=root(y,h)
if x!=y:
h[x]=min(x,y)
h[y]=h[x]
from collections import defaultdict
n,k,l=map(int,input().split())
a=[i for i in range(n+1)]
b=[i for i in range(n+1)]
for i in range(k):
s,t=map(int,input().split())
unite(s,t,a)
for i in range(l):
s,t=map(int,input().split())
unite(s,t,b)
d=defaultdict(int)
l=""
for i in range(1,n+1):
d[(root(a[i],a),root(b[i],b))]+=1
for i in range(1,n+1):
l+=str(d[(root(a[i],a),root(b[i],b))])+" "
print(l[:-1]) |
s392360639 | p03855 | u785578220 | 1552794743 | Python | Python (3.4.3) | py | Runtime Error | 28 | 3692 | 1553 | from collections import defaultdict
n,k,l = map(int, input().split())
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
D = defaultdict(int)
uf = UnionFind()
tf = UnionFind()
n,k,l = map(int, input().split())
dp =[1]*n
for i in range(k):
x,y =map(int, input().split())
uf.unite(x-1, y-1) # (3)
for i in range(l):
x,y =map(int, input().split())
tf.unite(x-1, y-1) # (3)
tf.all_find()
uf.all_find()
D = defaultdict(int)
for r, t in zip(uf.par, tf.par):
D[(r, t)] += 1
ans = [D[(r, t)] for r, t in zip(uf.par, tf.par)]
print(*ans, sep=' ') |
s730689591 | p03855 | u785578220 | 1552794693 | Python | Python (3.4.3) | py | Runtime Error | 21 | 3316 | 1555 | from collections import defaultdict
N, K, L = map(int, input().split())
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
D = defaultdict(int)
uf = UnionFind()
tf = UnionFind()
n,k,l = map(int, input().split())
dp =[1]*n
for i in range(k):
x,y =map(int, input().split())
uf.unite(x-1, y-1) # (3)
for i in range(l):
x,y =map(int, input().split())
tf.unite(x-1, y-1) # (3)
tf.all_find()
uf.all_find()
D = defaultdict(int)
for r, t in zip(uf.par, tf.par):
D[(r, t)] += 1
ans = [D[(r, t)] for r, t in zip(uf.par, tf.par)]
print(*ans, sep=' ') |
s524469335 | p03855 | u785578220 | 1552794682 | Python | PyPy3 (2.4.0) | py | Runtime Error | 161 | 38256 | 1555 | from collections import defaultdict
N, K, L = map(int, input().split())
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
self.size[x] = 0
else:
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# すべての頂点に対して親を検索する
def all_find(self):
for n in range(len(self.par)):
self.find(n)
D = defaultdict(int)
uf = UnionFind()
tf = UnionFind()
n,k,l = map(int, input().split())
dp =[1]*n
for i in range(k):
x,y =map(int, input().split())
uf.unite(x-1, y-1) # (3)
for i in range(l):
x,y =map(int, input().split())
tf.unite(x-1, y-1) # (3)
tf.all_find()
uf.all_find()
D = defaultdict(int)
for r, t in zip(uf.par, tf.par):
D[(r, t)] += 1
ans = [D[(r, t)] for r, t in zip(uf.par, tf.par)]
print(*ans, sep=' ') |
s946307206 | p03855 | u588341295 | 1548358605 | Python | Python (3.4.3) | py | Runtime Error | 662 | 23692 | 2075 | # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc065/editorial.pdf
・Union-Find木
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
from collections import Counter
# Union-Find木
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。par[x] == xの時そのノードは根
# 1-indexedのままでOK、その場合は[0]は未使用
self.par = [i for i in range(n+1)]
# 木の高さを格納する（初期状態では0）
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
# 木の高さが同じなら片方を1増やす
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
N, K, L = map(int, input().split())
uf1 = UnionFind(N)
uf2 = UnionFind(N)
for i in range(K):
p, q = map(int, input().split())
uf1.union(p, q)
for i in range(L):
p, q = map(int, input().split())
uf2.union(p, q)
# (道路グループ番号, 鉄道グループ番号) のペアを各都市について作る
pairs = [None] * N
for i in range(N):
pairs[i] = (uf1.find[i+1], uf2.find[i+1])
# 同じ内容のペアについて数える
c = Counter(pairs)
ans = [0] * N
for i in range(N):
# 自分のペアのカウント数を各都市について取得
ans[i] = c[pairs[i]]
print(*ans)
|
s473964063 | p03855 | u844789719 | 1547866809 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3440 | 876 | import copy
N, M = [int(_) for _ in input().split()]
AB = [[int(_) - 1 for _ in input().split()] for _ in range(M)]
G = [set() for _ in range(N)]
a = set()
for ab in AB:
G[ab[0]].add(ab[1])
def find(a, x):
stack = []
while a[x] != x:
stack += [x]
x = a[x]
while stack:
a[stack.pop()] = x
return x
def unite(a, x, y):
x = find(a, x)
y = find(a, y)
a[x] = a[y] = min(x, y)
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
if j in G[i]:
Gn = copy.deepcopy(G)
Gn[i].discard(j)
a = [i for i in range(N)]
for k in range(N - 1):
for l in Gn[k]:
unite(a, k, l)
par = set()
for k in range(N):
par.add(find(a, k))
if len(par) > 1:
ans += 1
print(ans)
|
s917998869 | p03855 | u844789719 | 1547866175 | Python | Python (3.4.3) | py | Runtime Error | 1319 | 47504 | 735 | N, K, L = [int(_) for _ in input().split()]
def find(a, x):
stack = []
while a[x] != x:
x = a[x]
stack += [x]
while stack:
a[stack.pop()] = x
return x
def unite(a, x, y):
x = find(a, x)
y = find(a, y)
a[x] = a[y] = min(x, y)
a_road = [i for i in range(N)]
for _ in range(K):
p, q = [int(_) - 1 for _ in input().split()]
unite(a_road, p, q)
a_railway = [i for i in range(N)]
for _ in range(L):
r, s = [int(_) - 1 for _ in input().split()]
unite(a_railway, r, s)
memo = {}
for i in range(N):
memo[a_road[i], a_railway[i]] = memo.get(
(find(a_road, i), find(a_railway, i)), 0) + 1
print(' '.join(str(memo[a_road[i], a_railway[i]]) for i in range(N)))
|
s595489297 | p03855 | u844789719 | 1547866132 | Python | Python (3.4.3) | py | Runtime Error | 1314 | 47508 | 735 | N, K, L = [int(_) for _ in input().split()]
def find(a, x):
stack = []
while a[x] != x:
x = a[x]
stack += [x]
while stack:
a[stack.pop()] = x
return x
def unite(a, x, y):
x = find(a, x)
y = find(a, y)
a[x] = a[y] = min(x, y)
a_road = [i for i in range(N)]
for _ in range(K):
p, q = [int(_) - 1 for _ in input().split()]
unite(a_road, p, q)
a_railway = [i for i in range(N)]
for _ in range(L):
r, s = [int(_) - 1 for _ in input().split()]
unite(a_railway, r, s)
memo = {}
for i in range(N):
memo[a_road[i], a_railway[i]] = memo.get(
(find(a_road, i), find(a_railway, i)), 0) + 1
print(' '.join(str(memo[a_road[i], a_railway[i]]) for i in range(N)))
|
s050256386 | p03855 | u391331433 | 1546553870 | Python | Python (2.7.6) | py | Runtime Error | 1595 | 205044 | 1682 |
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
if fileobject == None :
return raw_input
else:
return fileobject.readline
def bfs(N, path, res):
is_visited = [False for i in range(N + 1)]
for i in range(1, N + 1):
if is_visited[i] == True:
continue
que = deque([i])
res[i] = set([i])
while 1:
if len(que) <= 0:
break
p = que.popleft()
is_visited[p] = True
for q in path[p]:
if is_visited[q] == False:
is_visited[q] = True
res[i].add(q)
#res[q] = res[i]
que.append(q)
def main():
if len(sys.argv) > 1:
f = open(sys.argv[1])
else:
f = None
read_func = get_read_func(f);
input_raw = read_func().strip().split()
[N, K, L] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
road = {}
train = {}
for i in range(1, N + 1):
road[i] = []
train[i] = []
for i in range(K):
input_raw = read_func().strip().split()
[p, q] = [int(input_raw[0]), int(input_raw[1])]
road[p].append(q)
road[q].append(p)
res_road = {}
bfs(N, road, res_road)
for i in range(L):
input_raw = read_func().strip().split()
[p, q] = [int(input_raw[0]), int(input_raw[1])]
train[p].append(q)
train[q].append(p)
res_train = {}
bfs(N, train, res_train)
for i in range(1, N + 1):
print len(res_road[i] & res_train[i]),
if __name__ == '__main__':
main() |
s051113756 | p03855 | u215329188 | 1546466443 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 139880 | 905 | import numpy as np
N,K,L = map(int, input().split())
#print(N,K,L,D,T)
array_D = np.eye(N,N,dtype=int)
array_T = np.eye(N,N,dtype=int)
root_D = [i for i in range(N)]
root_T = [i for i in range(N)]
for _ in range(K):
d0, d1 = map(int, input().split())
d0 = d0 - 1
d1 = d1 - 1
r0 = root_D[d0]
r1 = root_D[d1]
array_D[r0] = array_D[r0] | array_D[r1]
root_D[r1] = r0
root_D[d1] = r0
#print(list_D, root_D)
for _ in range(L):
t0, t1 = map(int, input().split())
t0 = t0 - 1
t1 = t1 - 1
r0 = root_T[t0]
r1 = root_T[t1]
array_T[r0] = array_T[r0] | array_T[r1]
root_T[r1] = r0
root_T[t1] = r0
#print(list_T, root_T)
#和集合
res = [0] * N
for i in range(N):
rd = root_D[i]
rt = root_T[i]
d = array_D[rd]
t = array_T[rt]
res[i] = sum(d & t)
#print(*(res[i] for i in range(N)))
print(" ".join([str(i) for i in res])) |
s117638613 | p03855 | u215329188 | 1546464166 | Python | Python (3.4.3) | py | Runtime Error | 538 | 121924 | 903 | N,K,L = map(int, input().split())
#print(N,K,L,D,T)
list_D = [set([i]) for i in range(N)]
list_T = [set([i]) for i in range(N)]
root_D = [i for i in range(N)]
root_T = [i for i in range(N)]
#print(list_D)
for _ in range(K):
d = map(int, input().split())
d0 = d[0] - 1
d1 = d[1] - 1
r0 = root_D[d0]
r1 = root_D[d1]
list_D[r0] = list_D[r0] | list_D[r1]
root_D[r1] = r0
root_D[d1] = r0
#print(list_D, root_D)
for _ in range(L):
t = map(int, input().split())
t0 = t[0] - 1
t1 = t[1] - 1
r0 = root_T[t0]
r1 = root_T[t1]
list_T[r0] = list_T[r0] | list_T[r1]
root_T[r1] = r0
root_T[t1] = r0
#print(list_T, root_T)
#和集合
res = [0] * N
for i in range(N):
rd = root_D[i]
rt = root_T[i]
d = list_D[rd]
t = list_T[rt]
res[i] = len(d & t)
#print(*(res[i] for i in range(N)))
print(" ".join([str(i) for i in res])) |
s841534297 | p03855 | u215329188 | 1546464138 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 907 | N,K,L = map(int, input().split())
#print(N,K,L,D,T)
list_D = [set([i]) for i in range(N)]
list_T = [set([i]) for i in range(N)]
root_D = [i for i in range(N)]
root_T = [i for i in range(N)]
#print(list_D)
for _ in range(K):
d = map(int, input().split())
d0 = d[0] - 1
d1 = d[1] - 1
r0 = root_D[d0]
r1 = root_D[d1]
list_D[r0] = list_D[r0] | list_D[r1]
root_D[r1] = r0
root_D[d1] = r0
#print(list_D, root_D)
for for _ in range(L):
t = map(int, input().split())
t0 = t[0] - 1
t1 = t[1] - 1
r0 = root_T[t0]
r1 = root_T[t1]
list_T[r0] = list_T[r0] | list_T[r1]
root_T[r1] = r0
root_T[t1] = r0
#print(list_T, root_T)
#和集合
res = [0] * N
for i in range(N):
rd = root_D[i]
rt = root_T[i]
d = list_D[rd]
t = list_T[rt]
res[i] = len(d & t)
#print(*(res[i] for i in range(N)))
print(" ".join([str(i) for i in res])) |
s357325689 | p03855 | u215329188 | 1546464064 | Python | Python (3.4.3) | py | Runtime Error | 2124 | 303336 | 934 | N,K,L = map(int, input().split())
D = [list(map(int, input().split())) for _ in range(K)]
T = [list(map(int, input().split())) for _ in range(L)]
#print(N,K,L,D,T)
list_D = [set([i]) for i in range(N)]
list_T = [set([i]) for i in range(N)]
root_D = [i for i in range(N)]
root_T = [i for i in range(N)]
#print(list_D)
for d in D:
d0 = d[0] - 1
d1 = d[1] - 1
r0 = root_D[d0]
r1 = root_D[d1]
list_D[r0] = list_D[r0] | list_D[r1]
root_D[r1] = r0
root_D[d1] = r0
#print(list_D, root_D)
for t in T:
t0 = t[0] - 1
t1 = t[1] - 1
r0 = root_T[t0]
r1 = root_T[t1]
list_T[r0] = list_T[r0] | list_T[r1]
root_T[r1] = r0
root_T[t1] = r0
#print(list_T, root_T)
#和集合
#res = [0] * N
for i in range(N):
rd = root_D[i]
rt = root_T[i]
d = list_D[rd]
t = list_T[rt]
res[i] = len(d & t)
#print(*(res[i] for i in range(N)))
print(" ".join([str(i) for i in res])) |
s523634596 | p03855 | u920299620 | 1543267364 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 2186 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define itrfor(itr,A) for(auto itr = A.begin(); itr !=A.end();itr++)
typedef long long llong;
char moji[26]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
char moji2[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
char moji3[10]={'0','1','2','3','4','5','6','7','8','9'};
#define Sort(a) sort(a.begin(),a.end());
#define Reverse(a) reverse(a.begin(),a.end());
#define print(a) cout << a << endl;
#define n_max int(1e5+5)
struct UnionFind{
int A[n_max];
UnionFind( int n){
REP(i,n) A[i]=i;
}
int root(int a){
if(A[a] == a) return a;
int tmp;
tmp = root(A[a]);
A[a] = tmp;
return tmp;
}
bool same(int a, int b){
if(root(a) == root(b)) return true;
return false;
}
void merge(int a,int b){
A[root(a)] = root(b);
}
};
struct town{
int k,l;
int id;
};
bool comp(town a,town b){
if(a.k != b.k) return a.k < b.k;
else return a.l < b.l;
}
int main(){
int n,k,l;
cin >> n >> k >> l;
UnionFind K(n),L(n);
int a,b;
REP(i,k){
scanf("%d%d",&a,&b);
K.merge(a-1,b-1);
}
REP(i,l){
scanf("%d%d",&a,&b);
L.merge(a-1,b-1);
}
town T[n_max];
REP(i,n){
T[i].id=i;
T[i].k = K.root(i);
T[i].l = L.root(i);
}
sort(T,T+n,comp);
int ans[n_max]={};
int i=0;
while(1){
pair<int,int> p;
p.first = T[i].k;
p.second = T[i].l;
vector<int> ind;
ind.push_back(T[i].id);
while(1){
i+=1;
if(i < n and T[i].k == p.first and T[i].l == p.second){
ind.push_back(T[i].id);
}
else{
itrfor(itr,ind) ans[*itr] = ind.size();
break;
}
}
if(i >=n) break;
}
REP(i,n) cout << ans[i] << " ";
} |
s995858737 | p03855 | u366133198 | 1542065137 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 1821 | u'''Return all length combination'''
def all_comb(iterable):
for i in range(0, len(iterable) + 1):
comb = itertools.combinations(iterable, i)
for pair in comb:
yield(pair)
class UnionFind:
def __init__(self, elems=None):
class KeyDict(dict):
def __missing__(self, key):
self[key] = key
return key
self.parent = KeyDict()
self.rank = collections.defaultdict(int)
if elems is not None:
for elem in elems:
_, _ = self.parent[elem], self.rank[elem]
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def are_same(self, x, y):
return self.find(x) == self.find(y)
def grouper(self):
roots = [(x, self.find(x_par)) for x, x_par in self.parent.items()]
root = operator.itemgetter(1)
for _, group in itertools.groupby(sorted(roots, key=root), root):
yield [x for x, _ in group]
N, K, L = map(int, input().split())
load_connections = UnionFind(range(1, N + 1))
rail_connections = UnionFind(range(1, N + 1))
for i in range(K):
(p, q) = map(int, input().split())
load_connections.unite(p, q)
for i in range(L):
(r, s) = map(int, input().split())
rail_connections.unite(r, s)
for i in range(1, N + 1):
print([load_connections.are_same(i, j) and rail_connections.are_same(i, j) for j in range(1, N + 1)].count(True))
|
s115005141 | p03855 | u658993896 | 1541726618 | Python | Python (3.4.3) | py | Runtime Error | 1701 | 83712 | 887 | def bps(gr,p,s,num):
if gr[s]!=-1:
return
gr[s]=num
for x in p[s]:
bps(gr,p,x,num)
N,K,L=list(map(int,input().split()))
dic={}
road=[[] for _ in range(N)]
rail=[[] for _ in range(N)]
for i in range(K):
p,q=list(map(int,input().split()))
road[p-1].append(q-1)
road[q-1].append(p-1)
for i in range(L):
r,s=list(map(int,input().split()))
rail[r-1].append(s-1)
rail[s-1].append(r-1)
roadG=[-1 for _ in range(N)]
num=0
for i in range(N):
if roadG[i]==-1:
bps(roadG,road,i,num)
num+=1
railG=[-1 for _ in range(N)]
num=0
for i in range(N):
if railG[i]==-1:
bps(railG,rail,i,num)
num+=1
dic={}
arr=[]
for i in range(N):
key=roadG[i]*N+railG[i]
arr.append(key)
dic[key]=dic.setdefault(key,0)+1
print(dic[arr[0]],end='')
for x in arr[1:]:
print(' {}'.format(dic[x]),end='')
print('') |
s733231867 | p03855 | u883048396 | 1539896143 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 1312 | #Union-Find木の構築
import sys
def 解():
iN,iK,iL = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
def buildTree(a):
aT = [0]*(iN+1)
for p,q in a:
#if p > q :
# p,q = q,p
thisroot = max(aT[q],aT[p],q) #試しにデカい方に合わせる
if p <= aT[q] < thisroot: #2個づつ来るからこんなんでいいだろ
aT[aT[q]] = thisroot
if p <= aT[p] < thisroot:
aT[aT[p]] = thisroot
aT[q] = thisroot
aT[p] = thisroot
return aT
def getRoot(a,i):
if a[i] == i or a[i] == 0:
if a[i] == 0 : a[i] = i
return i
elif i < a[i] :
a[i] = getRoot(a,a[i])
return a[i]
else:
# print("! ",i,a[i])
aT道 = buildTree(aD[0:iK])
aT鉄道 = buildTree(aD[iK:])
aRet = []
dRet = {}
for i in range(1,iN+1):
# いやはやこんなもんもキーになるのか。
Comb = (getRoot(aT道,i), getRoot(aT鉄道,i))
aRet.append(Comb)
if Comb in dRet:
dRet[Comb] += 1
else:
dRet[Comb] = 1
print(" ".join([str(dRet[_]) for _ in aRet]))
解()
|
s505332805 | p03855 | u883048396 | 1539831285 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 1772 | mport sys
sys.setrecursionlimit(10**5)
def 解():
iN,iK,iL = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
a道 = aD[0:iK]
a鉄道 = aD[iK:]
d道 = {}
d鉄道 = {}
# for i in range(1,iN+1):
# d道[i] = {i}
# d鉄道[i] ={i}
def fMakeSet(d,x,y):
if x in d:
d[x].add(y)
else:
d[x] = {y}
for p,q in a道:
#d道[p].add(q)
#d道[q].add(p)
fMakeSet(d道,q,p)
fMakeSet(d道,p,q)
for r,s in a鉄道:
fMakeSet(d鉄道,r,s)
fMakeSet(d鉄道,s,r)
def fdfs(d,iS):
dsVisited=set()
def digRoute(iT):
dsVisited.add(iT)
if iT in d:
for i in d[iT] - dsVisited:
#dsVisited.add(i)
digRoute(i)
digRoute(iS)
return dsVisited
def buildGroup(d):
gl = {}
gidx = {}
v = set()
iC = 0
for i in range(1,iN+1):
if i in v:
continue
else:
dsList = fdfs(d,i)
for i in dsList:
gidx[i] = iC
gl[iC]=dsList
iC += 1
v = v | dsList
return (gl,gidx)
dg鉄道,idxdg鉄道 = (buildGroup(d鉄道))
dg道,idxdg道 = (buildGroup(d道))
ak鉄道 = dg鉄道.keys()
ak道 = dg道.keys()
aM = [[ None for _ in range(len(ak道))] for _ in range(len(ak鉄道))]
for i in ak鉄道:
for j in ak道:
aM[i][j]=len(dg鉄道[i] & dg道[j])
aRet = []
for i in range(1,iN+1):
aRet.append(str(aM[idxdg鉄道[i]][idxdg道[i]]))
print( " ".join(aRet))
解()
|
s945835154 | p03855 | u883048396 | 1539819646 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 824 | import sys
sys.setrecursionliit(10**5)
def 解():
iN,iK,iL = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
a道 = aD[0:iK]
a鉄道 = aD[iK:]
d道 = {}
d鉄道 = {}
for i in range(1,iN+1):
d道[i] = {i}
d鉄道[i] ={i}
for p,q in a道:
d道[p].add(q)
d道[q].add(p)
for r,s in a鉄道:
d鉄道[r].add(s)
d鉄道[s].add(r)
def fdfs(d,iS):
dsVisited=set()
def digRoute(iT):
for i in d[iT] - dsVisited:
dsVisited.add(i)
digRoute(i)
digRoute(iS)
return dsVisited
aRet = []
for i in range(1,iN+1):
aRet.append(str(len(fdfs(d道,i) & fdfs(d鉄道,i))))
print( " ".join(aRet))
解() |
s824467625 | p03855 | u883048396 | 1539819364 | Python | Python (3.4.3) | py | Runtime Error | 2115 | 208456 | 672 | import sys
iN,iK,iL = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
a道 = aD[0:iK]
a鉄道 = aD[iK:]
d道 = {}
d鉄道 = {}
for i in range(1,iN+1):
d道[i] = {i}
d鉄道[i] ={i}
for p,q in a道:
d道[p].add(q)
d道[q].add(p)
for r,s in a鉄道:
d鉄道[r].add(s)
d鉄道[s].add(r)
def fdfs(d,iS):
dsVisited=set()
def digRoute(iT):
for i in d[iT] - dsVisited:
dsVisited.add(i)
digRoute(i)
digRoute(iS)
return dsVisited
aRet = []
for i in range(1,iN+1):
aRet.append(str(len(fdfs(d道,i) & fdfs(d鉄道,i))))
print( " ".join(aRet))
|
s398583389 | p03855 | u069838609 | 1535849840 | Python | Python (3.4.3) | py | Runtime Error | 17 | 2940 | 37 | 7 4 4
1 2
2 3
2 5
6 7
3 5
4 5
3 4
6 7 |
s022405525 | p03855 | u826263061 | 1534360856 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3192 | 1605 | # -*- coding: utf-8 -*-
"""
Created on Wed Aug 15 14:20:12 2018
ABC049D
@author: maezawa
"""
n, k, l = list(map(int, input().split()))
road = [{}]
rail = [{}]
for i in range(k):
pi, qi = list(map(int, input().split()))
j = 0
while j<len(road):
if road[j] == {}:
road[j] = {pi, qi}
break
elif pi in road[j] or qi in road[j]:
road[j] |= {pi, qi}
if len(road)>j+1:
for m in range(j+1,len(road)):
if pi in road[m] or qi in road[m]:
road[j] |= road[m]
road.pop(m)
break
else:
road.append({pi, qi})
j += 1
#print(*road)
for i in range(l):
pi, qi = list(map(int, input().split()))
j = 0
while j<len(rail):
if rail[j] == {}:
rail[j] = {pi, qi}
break
elif pi in rail[j] or qi in rail[j]:
rail[j] |= {pi, qi}
if len(rail)>j+1:
for m in range(j+1,len(rail)):
if pi in rail[m] or qi in rail[m]:
rail[j] |= rail[m]
rail.pop(m)
break
else:
rail.append({pi, qi})
j += 1
#print(*rail)
ans = [1]*n
for roadset in road:
for railset in rail:
randr = roadset & railset
if randr != {}:
lenrandr = len(randr)
for i in randr:
ans[i-1] = lenrandr
print(ans[0], end='')
for i in range(1, n):
print(' '+str(ans[i]), end='')
print()
|
s127434133 | p03855 | u826263061 | 1534360672 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3192 | 1601 | # -*- coding: utf-8 -*-
"""
Created on Wed Aug 15 14:20:12 2018
ABC049D
@author: maezawa
"""
n, k, l = list(map(int, input().split()))
road = [{}]
rail = [{}]
for i in range(k):
pi, qi = list(map(int, input().split()))
j = 0
while j<len(road):
if road[j] == {}:
road[j] = {pi, qi}
break
elif pi in road[j] or qi in road[j]:
road[j] |= {pi, qi}
if len(road)>j:
for m in range(j+1,len(road)):
if pi in road[m] or qi in road[m]:
road[j] |= road[m]
road.pop(m)
break
else:
road.append({pi, qi})
j += 1
#print(*road)
for i in range(l):
pi, qi = list(map(int, input().split()))
j = 0
while j<len(rail):
if rail[j] == {}:
rail[j] = {pi, qi}
break
elif pi in rail[j] or qi in rail[j]:
rail[j] |= {pi, qi}
if len(rail)>j:
for m in range(j+1,len(rail)):
if pi in rail[m] or qi in rail[m]:
rail[j] |= rail[m]
rail.pop(m)
break
else:
rail.append({pi, qi})
j += 1
#print(*rail)
ans = [1]*n
for roadset in road:
for railset in rail:
randr = roadset & railset
if randr != {}:
lenrandr = len(randr)
for i in randr:
ans[i-1] = lenrandr
print(ans[0], end='')
for i in range(1, n):
print(' '+str(ans[i]), end='')
print()
|
s074702191 | p03855 | u232852711 | 1532155860 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 1094 | n, k, l = list(map(int, input().split()))
def get_groups(n, m):
road = [[] for _ in range(n+1)]
for _ in range(m):
p, q = list(map(int, input().split()))
road[p].append(q)
road[q].append(p)
groups = [0]*(n+1)
group_idx = 1
for i in range(1, n+1):
if groups[i] == 0:
groups[i] = group_idx
connect = [i]
while len(connect) > 0:
cnct = connect[0]
connect = connect[1:]
for c in road[cnct]:
if groups[c] == 0:
groups[c] = group_idx
connect.append(c)
group_idx += 1
return groups
road_groups = get_groups(n, k)
train_groups = get_groups(n, l)
# print(road_groups, train_groups)
pairs = {}
for c in range(1, n+1):
key = (road_groups[c], train_groups[c])
if not key in pairs.keys():
pairs[key] = 1
else:
pairs[key] += 1
ans = ''
for c in range(1, n+1):
key = (road_groups[c], train_groups[c])
ans += f'{pairs[key]} '
print(ans)
|
s206541388 | p03855 | u333945892 | 1530239825 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 888 | import sys
sys.setrecursionlimit(10**8)
def find(x,table): #xの根を返す
if table[x] == x:
return x
else:
table[x] = find(table[x],table) #親の更新(根を直接親にして参照距離を短く)
return table[x]
def union(x,y,table,rank): #xとyを繋げる
x = find(x,table)
y = find(y,table)
if x == y:
return
if rank[x] > rank[y]:
table[y] = x
else:
table[x] = y
if rank[x] == rank[y]:
rank[y] += 1
def check(x,y,table):
if find(x,table) == find(y,table):
return True
else:
return False
N,M = map(int,input().split())
P_li = list(map(int,input().split()))
table = [i for i in range(N+1)] #木の親 table[x] == x なら根
rank = [1 for i in range(N+1)] #木の長さ
for i in range(0,M):
a,b = map(int, input().split())
union(a,b,table,rank)
ans = 0
for i in range(1,N+1):
if check(i,P_li[i-1],table):
ans += 1
print (ans)
|
s185585233 | p03855 | u941884460 | 1530009599 | Python | Python (3.4.3) | py | Runtime Error | 669 | 53612 | 1454 | N,K,L = map(int,input().split())
roads = [list(map(int,input().split())) for _ in range(K)]
rails = [list(map(int,input().split())) for _ in range(L)]
outputs = [1 for _ in range(N)]
class UF():
def __init__(self,size):
self.table = [-1 for _ in range(size)]
self.results = {}
def find(self,x):
target = x
while self.table[x] >= 0:
x = self.table[x]
if 0 < self.table[target] and self.table[target] != x:
self.table[target] = x
return x
def union(self,x,y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] < self.table[s2]:
self.table[s2] = s1
if s2 in self.results:
self.results[s1].add(self.results[s2])
self.results.delete(s2)
else:
self.results[s1].add(s2)
else:
self.table[s1] = s2
self.table[s2] -= 1
if s1 in self.results and s2 in self.results:
self.results[s2].add(self.results[s1])
self.results.delete(s1)
elif s2 in self.results:
self.results[s2].add(s1)
else:
self.results[s2] = set([s1,s2])
return
w = UF(N+1)
for r in roads:
w.union(r[0],r[1])
t = UF(N+1)
for l in rails:
t.union(l[0],l[1])
for x in range(1,N+1):
if w.find(x) in w.results and t.find(x) in t.results:
outputs[x-1] = len(w.results[w.find(x)] & t.results[t.find(x)])
else:
outputs[x-1] = 1
print(' '.join(map(str,outputs))) |
s204598248 | p03855 | u132434645 | 1526898712 | Python | Python (3.4.3) | py | Runtime Error | 2119 | 89720 | 765 | import sys
sys.setrecursionlimit(1000)
n, k, l = map(int, input().split())
a = [list() for _ in range(n)]
b = [list() for _ in range(n)]
for _ in range(k):
p, q = [int(x) - 1 for x in input().split()]
a[p].append(q)
a[q].append(p)
for _ in range(l):
r, s = [int(x) - 1 for x in input().split()]
b[r].append(s)
b[s].append(r)
def g(a, b, i, k):
b[i] = k
for e in a[i]:
if b[e] is not None: continue
g(a, b, e, k)
def f(a, b):
k = 0
for i in range(n):
if b[i] is not None: continue
g(a, b, i, k)
k += 1
c = [None] * n
f(a, c)
d = [None] * n
f(b, d)
e = {}
for i in range(n):
k = (c[i], d[i])
e[k] = e.get(k, 0) + 1
print(' '.join([str(e[(c[i], d[i])]) for i in range(n)]))
|
s437652819 | p03855 | u132434645 | 1526898648 | Python | Python (3.4.3) | py | Runtime Error | 1315 | 89720 | 724 | n, k, l = map(int, input().split())
a = [list() for _ in range(n)]
b = [list() for _ in range(n)]
for _ in range(k):
p, q = [int(x) - 1 for x in input().split()]
a[p].append(q)
a[q].append(p)
for _ in range(l):
r, s = [int(x) - 1 for x in input().split()]
b[r].append(s)
b[s].append(r)
def g(a, b, i, k):
b[i] = k
for e in a[i]:
if b[e] is not None: continue
g(a, b, e, k)
def f(a, b):
k = 0
for i in range(n):
if b[i] is not None: continue
g(a, b, i, k)
k += 1
c = [None] * n
f(a, c)
d = [None] * n
f(b, d)
e = {}
for i in range(n):
k = (c[i], d[i])
e[k] = e.get(k, 0) + 1
print(' '.join([str(e[(c[i], d[i])]) for i in range(n)]))
|
s569993973 | p03855 | u394271841 | 1525204534 | Python | Python (3.4.3) | py | Runtime Error | 2106 | 33712 | 830 | import sys
sys.setrecursionlimit(10000)
def root(n, tree):
if tree[n] == n:
return n
else:
tree[n] = root(tree[n], tree)
return tree[n]
n, k, l = map(int, input().split())
road = [i for i in range(n+1)]
railway = [i for i in range(n+1)]
tree = [i for i in range(n+1)]
for _ in range(k):
p, q = map(int, input().split())
road[p] = q
for _ in range(k):
p, q = map(int, input().split())
railway[p] = q
from itertools import combinations
for p, q in combinations(range(1,n+1), 2):
if (root(p, road) == root(q, road)) and (root(p, railway) == root(q, railway)):
tree[p] = q
count = [0 for _ in range(n+1)]
for i in range(1,n+1):
count[root(i, tree)] += 1
for i in range(1,n):
print(count[root(tree[i], tree)], end=' ')
print(count[root(tree[n], tree)], end='') |
s264413988 | p03855 | u394271841 | 1525204442 | Python | Python (3.4.3) | py | Runtime Error | 2106 | 35760 | 788 | def root(n, tree):
if tree[n] == n:
return n
else:
tree[n] = root(tree[n], tree)
return tree[n]
n, k, l = map(int, input().split())
road = [i for i in range(n+1)]
railway = [i for i in range(n+1)]
tree = [i for i in range(n+1)]
for _ in range(k):
p, q = map(int, input().split())
road[p] = q
for _ in range(k):
p, q = map(int, input().split())
railway[p] = q
from itertools import combinations
for p, q in combinations(range(1,n+1), 2):
if (root(p, road) == root(q, road)) and (root(p, railway) == root(q, railway)):
tree[p] = q
count = [0 for _ in range(n+1)]
for i in range(1,n+1):
count[root(i, tree)] += 1
for i in range(1,n):
print(count[root(tree[i], tree)], end=' ')
print(count[root(tree[n], tree)], end='') |
s624976368 | p03855 | u813098295 | 1522724349 | Python | Python (2.7.6) | py | Runtime Error | 1290 | 55340 | 1032 | class uf_tree:
def __init__(self, n):
self.sizes = [0] * n
self.par = range(n)
def find(self, x):
if x == self.par[x]:
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.par[y] = x
self.sizes[x] += self.sizes[y]
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.sizes[find(x)]
N, K, L = map(int, raw_input().split())
uf_1 = uf_tree(N+1)
uf_2 = uf_tree(N+1)
for i in range(K):
p, q = map(int, raw_input().split())
uf_1.unite(p, q)
for i in range(L):
r, s = map(int, raw_input().split())
uf_2.unite(r, s);
dic = {}
for i in range(1, N+1):
key = (uf_1.find(i), uf_2.find(i))
dic[key] = dic.get(key, 0) + 1
for i in range(1, N+1):
print dic[(d.find(i), t.find(i))],
|
s995617685 | p03855 | u899866687 | 1522277028 | Python | Python (3.4.3) | py | Runtime Error | 2229 | 2041204 | 1288 |
N,K,L=map(int,input().split())
road=[[0]*N for i in range(N)]
train=[[0]*N for j in range(N)]
for i in range(K):
p,q=map(int,input().split())
road[p-1][q-1]=1
road[q-1][p-1]=1
for j in range(L):
r,s=map(int,input().split())
train[r-1][s-1]=1
train[s-1][r-1]=1
def count_r(node,visited):
visited[node]=1
ans=sum(visited)
rt_visited=visited
for i in range(N):
if not visited[i] and road[node][i]:
visited[i]=1
rc_visited=count_r(i,visited)
c_cnt=sum(rc_visited)
if ans<c_cnt:
ans=c_cnt
rt_visited=rc_visited
return rt_visited
def count_t(node,visited):
visited[node]=1
ans=sum(visited)
rt_visited=visited
for i in range(N):
if not visited[i] and train[node][i]:
visited[i]=1
rc_visited=count_t(i,visited)
c_cnt=sum(rc_visited)
if ans<c_cnt:
ans=c_cnt
rt_visited=rc_visited
return rt_visited
ans=[0]*N
for i in range(N):
Flag=[0]*N
counted_r=count_r(i,Flag)
Flag=[0]*N
counted_t=count_t(i,Flag)
ans[i]=sum(counted_r[j]*counted_t[j] for j in range(N))
text=str(ans[0])
for i in range(1,N):
text+=" "+str(ans[i])
print(text) |
s611567523 | p03855 | u899866687 | 1522274475 | Python | Python (3.4.3) | py | Runtime Error | 2235 | 2031988 | 1365 | N,K,L=map(int,input().split())
road=[[0]*N for i in range(N)]
train=[[0]*N for j in range(N)]
for i in range(K):
p,q=map(int,input().split())
road[p-1][q-1]=1
road[q-1][p-1]=1
for j in range(L):
r,s=map(int,input().split())
train[r-1][s-1]=1
train[s-1][r-1]=1
def count_r(node,visited):
visited[node]=1
ans=sum(visited)
rt_visited=visited
for i in range(N):
if not visited[i] and road[node][i]:
visited[i]=1
rc_visited=count_r(i,visited)
c_cnt=sum(rc_visited)
if ans<c_cnt:
ans=c_cnt
rt_visited=rc_visited
return rt_visited
def count_t(node,visited):
visited[node]=1
ans=sum(visited)
rt_visited=visited
for i in range(N):
if not visited[i] and train[node][i]:
visited[i]=1
rc_visited=count_t(i,visited)
c_cnt=sum(rc_visited)
if ans<c_cnt:
ans=c_cnt
rt_visited=rc_visited
return rt_visited
counted_r=[ 0 for j in range(N)]
counted_t=[ 0 for j in range(N)]
ans=[0]*N
for i in range(N):
Flag=[0]*N
counted_r[i]=count_r(i,Flag)
Flag=[0]*N
counted_t[i]=count_t(i,Flag)
ans[i]=sum(counted_r[i][j]*counted_t[i][j] for j in range(N))
text=str(ans[0])
for i in range(1,N):
text+=" "+str(ans[i])
print(text) |
s578025079 | p03855 | u665415433 | 1507152222 | Python | Python (3.4.3) | py | Runtime Error | 2153 | 709700 | 1493 | import copy
N, K, L = [int(i) for i in input().split()]
ROAD = [[] for i in range(N + 1)]
TRAIN = [[] for i in range(N + 1)]
path = set([])
ans = [[0] * 2 for i in range(N + 1)]
ans_num = [0] * (N + 1)
for i in range(K):
a, b = [int(i) for i in input().split()]
ROAD[a].append(b)
ROAD[b].append(a)
for i in range(L):
a, b = [int(i) for i in input().split()]
TRAIN[a].append(b)
TRAIN[b].append(a)
def check(now, n):
for i in range(1, now):
if now in ans[i][n]:
return ans[i][n]
return []
def solve(now, visited, road): # 訪れたところを記録しておけば、後でその位置がスタートだった時に利用できる
if now in visited:
return path
visited.append(now)
path.add(now)
if len(road[now]) is 0:
return path
for go in range(len(road[now])):
solve(road[now][go], visited[:], road[:])
return path
tes = []
for i in range(1, N + 1):
tes = check(i, 0)
if len(tes) is 0:
path = set([])
tmp = solve(i, [], ROAD[:])
ans[i][0] = list(tmp)
else:
ans[i][0] = tes
tmp = set(tes)
tes = check(i, 1)
if len(tes) is 0:
path = set([])
tmp2 = solve(i, [], TRAIN[:])
ans[i][1] = list(tmp2)
else:
ans[i][1] = tes
tmp2 = set(tes)
ans_num[i] = copy.deepcopy(list(tmp & tmp2))
A = []
for i in range(1, len(ans_num)):
A.append(len(ans_num[i]))
print(' '.join(map(str, A)))
|
s353883679 | p03855 | u665415433 | 1506979346 | Python | Python (3.4.3) | py | Runtime Error | 2145 | 672780 | 1126 | import copy
N, K, L = [int(i) for i in input().split()]
ROAD = [[] for i in range(N + 1)]
TRAIN = [[] for i in range(N + 1)]
path = set([])
ans = [[0] * 2 for i in range(N+1)]
ans_num = [0]*(N+1)
for i in range(K):
a, b = [int(i) for i in input().split()]
ROAD[a].append(b)
ROAD[b].append(a)
for i in range(L):
a, b = [int(i) for i in input().split()]
TRAIN[a].append(b)
TRAIN[b].append(a)
def solve(now, visited, road): # 訪れたところを記録しておけば、後でその位置がスタートだった時に利用できる
if now in visited:
return path
visited.append(now)
path.add(now)
if len(road[now]) is 0:
return path
for go in range(len(road[now])):
solve(road[now][go], visited[:], road[:])
return path
for i in range(1, N+1):
path = set([])
tmp = solve(i, [], ROAD[:])
ans[i][0] = list(tmp)
path = set([])
tmp2 = solve(i, [], TRAIN[:])
ans[i][1] = list(tmp2)
ans_num[i] = copy.deepcopy(list(tmp & tmp2))
A = []
for i in range(1,len(ans_num)):
A.append(len(ans_num[i]))
print(' '.join(map(str,A))) |
s631937176 | p03855 | u353919145 | 1505833742 | Python | Python (2.7.6) | py | Runtime Error | 15 | 2892 | 1046 | import collections
def solution():
pArr = []
qArr = []
rArr = []
sArr = []
cities = []
answer = []
line = raw_input()
n, k, l = line.split(' ')
for i in range (n):
cities.append(i)
for i in range(k):
line = raw_input()
p, q = line.split(' ')
pArr.append(p)
qArr.append(q)
for i in range(l):
line = raw_input()
r,s = line.split(' ')
rArr.append(r)
sArr.append(s)
railways = {}
roads = {}
for i in range(k):
roads[i] = [pArr[i], qArr[i]]
for i in range(l):
railways[i] = [rArr[i], sArr[i]]
for i in range(n):
print traverse(cities[i], cities, railways, roads)
def traverse(city, cities, railways, roads):
q = collections.deque()
visited = {}
q.append(city)
visited[city] = True
numCities = 0
while len(q) != 0:
c = q.popleft()
if c in railways and c not in visited:
q.append(railways[c])
visited[railways[c]] = True
numCities+=1
if c in roads and c not in visited:
q.append(roads[c])
visited[roads[c]] = True
numCities+=1
return numCities
solution()
|
s434814552 | p03855 | u863370423 | 1505833582 | Python | Python (3.4.3) | py | Runtime Error | 2113 | 115608 | 1988 | class Node():
def __init__(self, value):
self.value = value
self.connect = []
self.visited = False
def getConnect(self):
return self.connect
def setConnect(self, connects):
self.connect = connects
def getConnectValues(self):
res = []
for node in self.connect:
res.append(node.getValue())
return res
def getValue(self):
return self.value
def addConnect(self, connectNode):
self.connect.append(connectNode)
def addConnects(self, connectNodes):
self.connect += connectNodes
def visitAll(self):
self.visited = True
for i in range(len(self.connect)):
if self.connect[i].visited:
continue
else:
self.connect[i].visitAll()
def computeAllConnects(node, list1):
node.visitAll()
res = []
for i in range(1,len(list1)):
if list1[i].visited:
res.append(list1[i])
node.setConnect(res)
refreshVisited(list1)
def refreshVisited(list1):
for i in range(1,len(list1)):
list1[i].visited = False
def computeDuplicate(list1, list2):
res = []
for i in list1:
if i in list2:
res.append(i)
return res
line1 = input()
line1 = line1.split(" ")
numCities = int(line1[0])
numRoads = int(line1[1])
numRails = int(line1[2])
road = [0]
rail = [0]
res = [0]
for i in range(1, numCities+1):
road.append(Node(i))
rail.append(Node(i))
for i in range(numRoads):
lineI = input().split(" ")
city1 = road[int(lineI[0])]
city2 = road[int(lineI[1])]
city1.addConnect(city2)
city2.addConnect(city1)
for i in range(numRails):
lineI = input().split(" ")
city1 = rail[int(lineI[0])]
city2 = rail[int(lineI[1])]
city1.addConnect(city2)
city2.addConnect(city1)
for i in range(1, numCities+1):
computeAllConnects(road[i], road)
computeAllConnects(rail[i], rail)
for i in range(1,numCities+1):
roadConnects = road[i].getConnectValues()
railConnects = rail[i].getConnectValues()
res.append(len(computeDuplicate(roadConnects, railConnects)))
res = res[1:]
for i in range(0,len(res)-1):
print(res[i], end=" ")
print(res[len(res)-1]) |
s247655483 | p03855 | u863370423 | 1505832654 | Python | Python (2.7.6) | py | Runtime Error | 10 | 2568 | 2701 | import java.util.*;
public class Main
{
public static void main(String... args){
Scanner sc= new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
int l = sc.nextInt();
// int n = 100000;
// int k = 100000;
// int l = 100000;
List<Set<Integer>> road = new ArrayList<>();
List<Set<Integer>> rail = new ArrayList<>();
for (int i = 0; i < n; i++) {
road.add(new HashSet<>());
rail.add(new HashSet<>());
}
for (int i = 0; i < k; i++) {
int s = sc.nextInt();
int t = sc.nextInt();
// int s = i + 1;
// int t = (i + 2) % 100000 + 1;
s--;
t--;
road.get(s).add(t);
road.get(t).add(s);
}
for (int i = 0; i < l; i++) {
int s = sc.nextInt();
int t = sc.nextInt();
// int s = i + 1;
// int t = (i + 1) % 100000 + 1;
s--;
t--;
rail.get(s).add(t);
rail.get(t).add(s);
}
Map<Integer, Set<Integer>> roadCon = new HashMap<>();
Map<Integer, Set<Integer>> railCon = new HashMap<>();
dfs(road, roadCon, n);
dfs(rail, railCon, n);
for (int i = 0; i < n; i++) {
System.out.print(intersect(roadCon.get(i), railCon.get(i)));
System.out.print(" ");
}
}
public static int intersect(Set<Integer>s1, Set<Integer>s2){
int total = 0;
if (s1.size() < s2.size()) {
for (int i : s1) {
if (s2.contains(i)) {
total++;
}
}
} else {
for (int i : s2) {
if (s1.contains(i)) {
total++;
}
}
}
return total;
}
public static void dfs(List<Set<Integer>> road, Map<Integer, Set<Integer>> con, int n){
boolean[] visited = new boolean[n];
for (int i = 0; i < n; i++) {
if (!visited[i]){
Stack<Integer> s = new Stack<>();
s.push(i);
Set<Integer> tocon = new HashSet<>();
while (!s.empty()){
int t = s.pop();
tocon.add(t);
visited[t] = true;
for (int j : road.get(t)) {
if (!visited[j]){
s.push(j);
}
}
}
for (int j : tocon) {
con.put(j, tocon);
}
}
}
}
} |
s276881158 | p03855 | u596276291 | 1501169610 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 99396 | 1929 | from collections import defaultdict
class UnionFind:
def __init__(self, size):
self.parent = list(range(size + 1))
def is_same_set(self, x: int, y: int) -> bool:
return self.find_root(x) == self.find_root(y)
def union_set(self, x: int, y: int):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
self.parent[x] = y
def find_root(self, x: int):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find_root(self.parent[x])
return self.parent[x]
def dfs(n, used, edges, uf: UnionFind):
used[n] = True
for a in edges[n]:
if not used[a]:
uf.union_set(n, a)
dfs(a, used, edges, uf)
def main():
N, K, L = map(int, input().split())
d1 = defaultdict(list)
for _ in range(K):
p, q = map(int, input().split())
p -= 1
q -= 1
d1[p].append(q)
d1[q].append(p)
d2 = defaultdict(list)
for _ in range(L):
r, s = map(int, input().split())
r -= 1
s -= 1
d2[r].append(s)
d2[s].append(r)
uf1 = UnionFind(N)
used1 = [False] * N
for n in range(N):
if not used1[n]:
dfs(n, used1, d1, uf1)
uf2 = UnionFind(N)
used2 = [False] * N
for n in range(N):
if not used2[n]:
dfs(n, used2, d2, uf2)
used3 = [False] * N
ans = [0] * N
for n1 in range(N):
if used3[n1]:
continue
num = 1
l = [n1]
for n2 in range(n1 + 1, N):
if not used3[n2]:
if uf1.is_same_set(n1, n2) and uf2.is_same_set(n1, n2):
used3[n2] = True
l.append(n2)
num += 1
for n in l:
ans[n] = num
print(" ".join(map(str, ans)))
if __name__ == '__main__':
main()
|
s529795948 | p03855 | u761320129 | 1496870727 | Python | Python (2.7.6) | py | Runtime Error | 667 | 17868 | 1892 | N,K,L = map(int, raw_input().split())
roads = [-1 for i in range(N)]
rails = [-1 for i in range(N)]
same_roads = {}
same_rails = {}
max_road_id = -1
for i in range(K):
p,q = map(int, raw_input().split())
p -= 1
q -= 1
if roads[p] < 0 and roads[q] < 0:
max_road_id += 1
roads[p] = max_road_id
roads[q] = max_road_id
elif roads[p] == roads[q]:
continue
elif roads[p] >= 0 and roads[q] < 0:
roads[q] = roads[p]
elif roads[q] < 0 and roads[q] >= 0:
roads[p] = roads[q]
else:
same_roads[max(roads[p],roads[q])] = min(roads[p],roads[q])
distinct_roads = [i for i in range(max_road_id + 1)]
for road_id in range(max_road_id, -1, -1):
if road_id in same_roads:
distinct_roads[road_id] = same_roads[road_id]
max_rail_id = -1
for i in range(L):
r,s = map(int, raw_input().split())
r -= 1
s -= 1
if rails[r] < 0 and rails[s] < 0:
max_rail_id += 1
rails[r] = max_rail_id
rails[s] = max_rail_id
elif rails[r] == rails[s]:
continue
elif rails[r] >= 0 and rails[s] < 0:
rails[s] = rails[r]
elif rails[r] < 0 and rails[s] >= 0:
rails[r] = rails[s]
else:
same_rails[max(rails[r],rails[s])] = min(rails[r],rails[s])
distinct_rails = [i for i in range(max_rail_id + 1)]
for rail_id in range(max_rail_id, -1, -1):
if rail_id in same_rails:
distinct_rails[rail_id] = same_rails[rail_id]
combi_counts = {}
for i in range(N):
road = roads[i]
rail = rails[i]
if road < 0 or rail < 0:
continue
if (road,rail) in combi_counts:
combi_counts[(distinct_roads[road],distinct_rails[rail])] += 1
else:
combi_counts[(distinct_roads[road],distinct_rails[rail])] = 1
result = []
for i in range(N):
road = roads[i]
rail = rails[i]
if road < 0 or rail < 0:
result.append(1)
else:
result.append(combi_counts[(distinct_roads[road],distinct_rails[rail])])
print ' '.join(map(str, result)) |
s441779431 | p03855 | u639045280 | 1482073193 | Python | PyPy3 (2.4.0) | py | Runtime Error | 1555 | 126720 | 548 | from collections import Counter
n,k,l = map(int, input().split())
def f(m):
a = [[] for _ in range(n)]
for _ in range(m):
p,q = map(int, input().split())
a[p-1].append(q-1)
a[q-1].append(p-1)
b = list(range(n))
for i in range(n):
def g(j):
if b[j] != j:
return
b[j] = i
for k in a[j]:
g(k)
g(i)
return b
a = f(k)
b = f(l)
c = Counter((a[i],b[i]) for i in range(n))
print(' '.join((str(c[a[i],b[i]]) for i in range(n))))
|
s334744540 | p03855 | u639045280 | 1482073078 | Python | Python (3.4.3) | py | Runtime Error | 1449 | 47388 | 547 | from collections import Counter
n,k,l = map(int, input().split())
def f(m):
a = [[] for _ in range(n)]
for _ in range(m):
p,q = map(int, input().split())
a[p-1].append(q-1)
a[q-1].append(p-1)
b = list(range(n))
for i in range(n):
def g(j):
if b[j] != j:
return
b[j] = i
for k in a[j]:
g(k)
g(i)
return b
a = f(k)
b = f(l)
c = Counter((a[i],b[i]) for i in range(n))
print(' '.join((str(c[a[i],b[i]]) for i in range(n)))) |
s316993724 | p03855 | u591287669 | 1481752570 | Python | Python (3.4.3) | py | Runtime Error | 1592 | 91116 | 819 | from collections import defaultdict
n,k,l=map(int,input().split())
st=[] # streets
rr=[] # railroads
for _ in range(n):
st.append([])
rr.append([])
for _ in range(k):
p,q = map(int,input().split())
st[p-1].append(q-1)
st[q-1].append(p-1)
for _ in range(l):
p,q = map(int,input().split())
rr[p-1].append(q-1)
rr[q-1].append(p-1)
st_m=[0]*n
rr_m=[0]*n
def dfs(G,cur,M,m):
M[cur]=m
for next_cur in G[cur]:
if M[next_cur]==0:
dfs(G,next_cur,M,m)
m=1
for i in range(n):
if st_m[i]==0:
dfs(st,i,st_m,m)
m+=1
m=1
for i in range(n):
if rr_m[i]==0:
dfs(rr,i,rr_m,m)
m+=1
dd=defaultdict(int)
for pair in zip(st_m,rr_m):
dd[pair]+=1
ans=[]
for pair in zip(st_m,rr_m):
ans.append(str(dd[pair]))
print(' '.join(ans))
|
s191990755 | p03855 | u237316771 | 1481429784 | Python | Python (2.7.6) | py | Runtime Error | 15 | 2568 | 1760 | #include <bits/stdc++.h>
using namespace std;
int table[2][200000] = {{}, {}};
int uffind(int i, int x) {
if (table[i][x] == -1) {
return x;
}
return (table[i][x] = uffind(i, table[i][x]));
}
void ufunion(int i, int x, int y) {
int s1 = uffind(i, x), s2 = uffind(i, y);
if (s1 != s2) {
table[i][s2] = s1;
}
}
int main() {
for (int i = 0; i < 200000; i++) {
table[0][i] = table[1][i] = -1;
}
int n, k, l;
cin >> n >> k >> l;
for (int i = 0; i < k; i++) {
int p, q;
cin >> p >> q;
p--; q--;
ufunion(0, p, q);
}
for (int i = 0; i < l; i++) {
int r, s;
cin >> r >> s;
r--; s--;
ufunion(1, r, s);
}
map<int, vector<int> > d2;
map<int, vector<int> > t2;
for (int i = 0; i < n; i++) {
int sd = uffind(0, i);
decltype(d2)::iterator itd = d2.find(sd);
if (itd == d2.end()) {
vector<int> vd(1, i);
d2.insert(make_pair(sd, vd));
} else {
itd->second.push_back(i);
}
int st = uffind(1, i);
decltype(t2)::iterator itt = t2.find(st);
if (itt == t2.end()) {
vector<int> vt(1, i);
t2.insert(make_pair(st, vt));
} else {
itt->second.push_back(i);
}
}
for (int i = 0; i < n; i++) {
decltype(d2)::iterator itd = d2.find(uffind(0, i));
decltype(t2)::iterator itt = t2.find(uffind(1, i));
vector<int> vd = itd->second;
vector<int> vt = itt->second;
vector<int> res(vd.size() + vt.size());
sort(vd.begin(), vd.end());
sort(vt.begin(), vt.end());
vector<int>::iterator it = set_intersection(vd.begin(), vd.end(), vt.begin(), vt.end(), res.begin());
res.resize(it - res.begin());
cout << res.size();
if (i != n - 1) {
cout << ' ';
}
}
cout << endl;
return 0;
}
|
s490440463 | p03856 | u973972117 | 1600028547 | Python | Python (3.8.2) | py | Runtime Error | 41 | 9168 | 411 | S = input()
N = len(S)
i = 0
while i < N:
sig = 0
S5 = S[i:i+5]
if S5 == 'dream':
sig = 1
if S[i+5:i+7] == 'er' and S[i+7] != 'a':
i += 2
i += 5
elif S5 == 'erase':
sig = 1
if S[i+5:i+6] == 'r':
i += 1
i += 5
if sig == 0:
sig = 2
Answer = 'NO'
break
if sig != 2:
Answer = 'YES'
print(Answer) |
s184391707 | p03856 | u973972117 | 1600028511 | Python | Python (3.8.2) | py | Runtime Error | 39 | 9156 | 411 | S = input()
N = len(S)
i = 0
while i < N:
sig = 0
S5 = S[i:i+5]
if S5 == 'dream':
sig = 1
if S[i+5:i+7] == 'er' and S[i+7] != 'a':
i += 2
i += 5
elif S5 == 'erase':
sig = 1
if S[i+5:i+6] == 'r':
i += 1
i += 5
if sig == 0:
sig = 2
Answer = 'No'
break
if sig != 2:
Answer = 'Yes'
print(Answer) |
s480912085 | p03856 | u973972117 | 1600028462 | Python | Python (3.8.2) | py | Runtime Error | 38 | 9136 | 411 | S = input()
N = len(S)
i = 0
while i < N:
sig = 0
S5 = S[i:i+5]
if S5 == 'dream':
sig = 1
if S[i+5:i+7] == 'er' and S[i+7] != 'a':
i += 2
i += 5
elif S5 == 'erase':
sig = 1
if S[i+5:i+6] == 'r':
i += 1
i += 5
if sig == 0:
sig = 2
Answer = 'No'
break
if sig != 2:
Answer = 'Yes'
print(Answer) |
s573952995 | p03856 | u018679195 | 1597693252 | Python | Python (3.8.2) | py | Runtime Error | 27 | 9180 | 218 | s=input()
s=s.replace('eraser','#')
s=s.replace('erase','#')
s=s.replace('dreamer','#')
s=s.replace('dream')
f=1
for it in s:
if it !='#':
f=0
break
if f==1:
print("YES")
else :
print("NO") |
s673481865 | p03856 | u554590385 | 1596770889 | Python | Python (3.8.2) | py | Runtime Error | 23 | 8968 | 358 | S=input()
for x in S:
if("dream" in S and "erase" in S):
print("YES")
break
elif("dream" in S and "eraser" in S):
print("YES")
break
elif( "dreamer" in S and "erase" in S):
print("YES")
break
if( "dreamer" in S and "eraser" in S):
print("YES")
break
else:
print("NO" |
s850062014 | p03856 | u102242691 | 1585394079 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 3316 | 258 |
s = input()
l = ["eraser","erase","dreamer","dream"]
while len(s) > 0:
for i in range(len(l)):
if l[i] in s:
s = s.replase(l[i],"")
else:
break
if len(s) == 0:
print("YES")
else:
print("NO")
|
s766839335 | p03856 | u102242691 | 1585394052 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3188 | 258 |
s = input()
l = ["dream","dreamer","erase","eraser"]
while len(s) > 0:
for i in range(len(l)):
if l[i] in s:
s = s.replase(l[i],"")
else:
break
if len(s) == 0:
print("YES")
else:
print("NO")
|
s752058154 | p03856 | u983918956 | 1574814735 | Python | PyPy3 (2.4.0) | py | Runtime Error | 182 | 42576 | 1885 | def main():
import sys
input = sys.stdin.readline
from collections import defaultdict
class Unionfind:
__slots__ = ['parents','sizes']
def __init__(self, n):
self.parents = list(range(n))
self.sizes = [1]*n
def root(self, x):
if self.parents[x] == x:
return x
else:
root_x = self.root(self.parents[x])
self.parents[x] = root_x
return root_x
def unite(self, x, y):
x = self.root(x); y = self.root(y)
if x == y:
return
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.sizes[x] += self.sizes[y]
self.parents[y] = x
def same(self, x, y):
return self.root(x) == self.root(y)
# 集合自体の数 ({1,2}, {3}, {4} : kind -> 3)
def kind(self):
for v in range(N):
self.root(v)
return len(list(set(self.parents)))
# xが属する集合の要素の数 ({1,2,3} : size(2) -> 3)
def size(self, x):
self.sizes[x] = self.sizes[self.root(x)]
return self.sizes[x]
N, K, L = map(int,input().split())
road = Unionfind(N)
train = Unionfind(N)
for _ in range(K):
p, q = map(int,input().split())
p -= 1; q -= 1
road.unite(p, q)
for _ in range(L):
r, s = map(int,input().split())
r -= 1; s -= 1
train.unite(r, s)
ans_list = []
r = defaultdict(set)
t = defaultdict(set)
for i in range(N):
r[road.root(i)].add(i)
t[train.root(i)].add(i)
ans_list = []
for i in range(N):
ans = len(r[road.root(i)] & t[train.root(i)])
ans_list.append(ans)
print(*ans_list)
if __name__ == "__main__":
main() |
s429548972 | p03856 | u405660020 | 1567975191 | Python | Python (3.4.3) | py | Runtime Error | 20 | 3188 | 143 | s=input()
s＝s.replace("eraser","").replace("erase","").replace("dreamer","").replace("dream","")
if s:
print("NO")
else:
print("YES") |
s494798780 | p03856 | u947883560 | 1561025120 | Python | Python (3.4.3) | py | Runtime Error | 127 | 98476 | 711 | #!/usr/bin/env python3
import sys
INF = float("inf")
def yes():
print("YES") # type: str
def no():
print("NO") # type: str
template = ["dream", "dreamer", "erase", "eraser"]
def dfs(s):
if len(s) == 0:
return True
for t in template:
if s.startswith(t):
if dfs(s[len(t):]):
return True
return False
def solve(S: str):
if dfs(S):
yes()
else:
no()
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
solve(S)
if __name__ == '__main__':
main()
|
s181584945 | p03856 | u367130284 | 1556509176 | Python | Python (3.4.3) | py | Runtime Error | 21 | 3564 | 1717 | from collections import*
class UNION_FIND(object):
def __init__(self,n):
#親の番号を格納する。親だった場合は-(その集合のサイズ)
#作るときはParentの値を全て-1にする
#こうすると全てバラバラになる
self.parent=[-1 for i in range(n)]
def root(self,x):
#Aがどのグループに属しているか調べる
if self.parent[x]<0:
return x
else:
self.parent[x]=self.root(self.parent[x]) #親を再帰で探知 再帰は最後に上のifにひっかかる
return self.parent[x]
def size(self,x):
#自分のいるグループの頂点数を調べる
return -self.parent[self.root(x)] #親をとってきたい
def union(self,x,y):
#AとBをくっ付ける
#AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
#print(self.parent)
x=self.root(x)
y=self.root(y)
#print(x,y)
if x==y: #すでにくっついてるからくっ付けない
return False
#大きい方(A)に小さいほう(B)をくっ付けたい
#大小が逆だったらひっくり返しちゃう。
if self.size(x)<self.size(y):
x,y=y,x
self.parent[x]+=self.parent[y] #Aのサイズを更新する
self.parent[y]=x #Bの親をAに変更する
return True
n,k,l=map(int,input().split())
u1=UNION_FIND(n)
u2=UNION_FIND(n)
d= defaultdict(int)
for i in range(k):
p,q=map(int,input().split())
u1.union(p-1,q-1)
for i in range(l):
p,q=map(int,input().split())
u2.union(p-1,q-1) |
s703633877 | p03856 | u623819879 | 1554958629 | Python | PyPy3 (2.4.0) | py | Runtime Error | 168 | 42480 | 1234 | # coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**9)
from collections import Counter
from collections import defaultdict
n,k,l=map(int,input().split())
p=[0]*(k+1)
q=[0]*(k+1)
rd=[[] for _ in range(n+1)]
r=[0]*(l+1)
s=[0]*(l+1)
rw=[[] for _ in range(n+1)]
for i in range(k):
a,b=map(int,input().split())
p[i],q[i]=a,b
rd[a].append(b)
rd[b].append(a)
for i in range(l):
a,b=map(int,input().split())
r[i],s[i]=a,b
rw[a].append(b)
rw[b].append(a)
prd=[i for i in range(n+1)]
def union(x,y):
rx=root(x)
ry=root(y)
if rx==ry:
return
p[rx]=ry
def root(x):
if p[x]==x:
return x
p[x]=root(p[x])
return p[x]
cnt=[[] for _ in range(n+1)]
#print(rd)
#print(rw)
p=prd
for i in range(1,n+1):
for j in rd[i]:
union(i,j)
for i in range(1,n+1):
rt=root(i)
prd[i]=rt
# cnt[i].append(rt)
p=[i for i in range(n+1)]
for i in range(1,n+1):
for j in rw[i]:
union(i,j)
for i in range(1,n+1):
rt=root(i)
p[i]=rt
# cnt[i].append(rt)
#print(cnt)
#c=Counter(cnt)
dc=defaultdict(int)
for i in range(1,n+1):
dc[prd[i],p[i]] += 1
#for i in range(n+1):
print(*[dc[prd[i],p[i]] for i in range(1,n+1)]) |
s061885079 | p03856 | u280512618 | 1551645563 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 3444 | 497 | from collections import deque
def solve(s):
que = deque()
que.append(s)
while len(que) > 0:
top = que.pop()
if top == '':
return 'YES'
if top[:5] == 'dream':
if top[5:7] == 'er':
que.append(s[:7])
que.append(s[:5])
elif top[:5] == 'erase':
if top[5] == 'r':
que.append(top[:6])
else:
que.append(top[:5])
return 'NO'
print(solve(input()))
|
s345262493 | p03856 | u280512618 | 1551644854 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 214 | s = input()
while s != '':
if s[:5] == 'dream' or s[:5] == 'erase':
if s[5] == 'r':
s = s[6:]
else:
s = s[5:]
else:
print('NO')
quit(0)
print('YES')
|
s423214975 | p03856 | u280512618 | 1551644817 | Python | Python (3.4.3) | py | Runtime Error | 18 | 2940 | 213 | s = input()
while s != '':
if s[:5] == 'dream' or s[:5] == 'erase':
if s[5] = 'r':
s = s[6:]
else:
s = s[5:]
else:
print('NO')
quit(0)
print('YES')
|
s104421300 | p03856 | u593063683 | 1549623944 | Python | Python (3.4.3) | py | Runtime Error | 127 | 7368 | 590 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 8 05:12:38 2019
@author: shinjisu
"""
def db(x):
global debug
if debug:
print(x)
def gen(tstr):
if len(tstr) <= len(S):
for w in words:
yield w + tstr
for w2 in gen(w + tstr):
yield w2
else:
yield tstr
debug = False
words = ('dream', 'dreamer', 'erase', 'eraser')
S = input()
ans = False
db(S)
for genstr in gen(''):
db(genstr)
if genstr == S:
ans = True
break
if ans:
print('YES')
else:
print('NO')
|
s408627313 | p03856 | u054106284 | 1548770327 | Python | Python (3.4.3) | py | Runtime Error | 81 | 3188 | 369 | S = ' ' + input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[:len(S)-5]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[:len(S)-7]
elif len(S) >= 5 and S[len(S)-5:] == 'erase':
S = S[:len(S)-5]
elif len(S) >= 6 and S[len(S)-6:] == 'eraser':
S = S[:len(S)-6]
else:
break
if S == ' ':
print(YES)
else:
print(NO)
|
s784478548 | p03856 | u054106284 | 1548769945 | Python | Python (3.4.3) | py | Runtime Error | 79 | 3188 | 356 | S = input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[:len(S)-5]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[:len(S)-7]
elif len(S) >= 5 and S[len(S)-5:] == 'erase':
S = S[:len(S)-5]
elif len(S) >= 6 and S[len(S)-6:] == 'eraser':
S = S[:len(S)-6]
else:
break
if S:
print(NO)
else:
print(YES)
|
s446890033 | p03856 | u054106284 | 1548769154 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 3188 | 356 | S = input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[len(S)-5:]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[len(S)-7:]
elif len(S) >= 5 and S[len(S)-5:] == 'erase':
S = S[len(S)-5:]
elif len(S) >= 6 and S[len(S)-6:] == 'eraser':
S = S[len(S)-6:]
else:
break
if S:
print(NO)
else:
print(YES)
|
s686783264 | p03856 | u054106284 | 1548768986 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 3188 | 356 | S = input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[len(S)-5:]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[len(S)-7:]
elif len(S) >= 5 and S[len(S)-5:] == 'erase':
S = S[len(S)-5:]
elif len(S) >= 6 and S[len(S)-6:] == 'eraser':
S = S[len(S)-6:]
else:
break
if S:
print(YES)
else:
print(NO)
|
s285937396 | p03856 | u054106284 | 1548768907 | Python | Python (3.4.3) | py | Runtime Error | 20 | 3188 | 352 | S = input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[len(S)-5]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[len(S)-7]
elif len(S) >= 5 and S[len(S)-5:] == 'erase':
S = S[len(S)-5]
elif len(S) >= 6 and S[len(S)-6:] == 'eraser':
S = S[len(S)-6]
else:
break
if S:
print(YES)
else:
print(NO)
|
s933656095 | p03856 | u054106284 | 1548768824 | Python | Python (3.4.3) | py | Runtime Error | 19 | 3188 | 337 | S = input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[len(S)-5]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[len(S)-7]
elif len(S) >= 5 and S[len(S)-5:] == 'erase':
S = S[len(S)-5]
elif len(S) >= 6 and S[len(S)-6:] == 'eraser':
S = S[len(S)-6]
else:
break
if S:
print(YES)
else:
print(NO)
|
s604224220 | p03856 | u054106284 | 1548768773 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 337 | S = input()
while True:
if len(S) >= 5 and S[len(S)-5:] == 'dream':
S = S[len(S)-5]
elif len(S) >= 7 and S[len(S)-7:] == 'dreamer':
S = S[len(S)-7]
elif len(S) >= 5 and S[len(S)-7:] == 'erase':
S = S[len(S)-5]
elif len(S) >= 7 and S[len(S)-7:] == 'eraser':
S = S[len(S)-6]
else:
break
if S:
print(YES)
else:
print(NO)
|
s159476943 | p03856 | u054106284 | 1548768622 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 336 | S = input()
while True:
if len(S) >= 5 and S[len(s)-5:] == 'dream':
S = S[len(s)-5]
elif len(S) >= 7 and S[len(s)-7:] == 'dreamer':
S = S[len(s)-7]
elif len(S) >= 5 and S[len(s)-7:] == 'erase':
S = S[len(s)-5]
elif len(S) >= 7 and S[len(s)-7:] == 'eraser':
S = S[len(s)-6]
else:
break
if S:
print(YES)
else:
print(NO) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.