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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
s032683688 | p03854 | u143492911 | 1518065603 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 144 | s=input().replace("erase","").replace("dream",""),replace("eraser","").replace("dreamer","")
if s in "":
print("YES")
else:
print("NO")
|
s956958532 | p03854 | u875361824 | 1515188944 | Python | Python (3.4.3) | py | Runtime Error | 84 | 4316 | 1128 | def main():
S = input()
dfs(S)
def dfs(S):
l = len(S)
if _dfs(S, l, 0):
print("YES")
else:
print("NO")
def _dfs(S, l, idx, pattern=0):
# print(l, idx, pattern)
if idx == l:
return True
if S[idx:idx + 7] == "dreamer":
ok = _dfs(S, l, idx + 7, 1)
if ok:
return True
if S[idx:idx + 6] == "eraser":
ok = _dfs(S, l, idx + 6, 2)
if ok:
return True
if S[idx:idx + 5] == "dream" or \
S[idx:idx + 5] == "erase":
ok = _dfs(S, l, idx + 5, 3)
if ok:
return True
return False
def WA(S):
l = len(S)
idx = 0
ok = True
while idx < l:
if S[idx:idx + 7] == "dreamer":
idx += 7
elif S[idx:idx + 6] == "eraser":
idx += 6
elif S[idx:idx + 5] == "dream" or \
S[idx:idx + 5] == "erase":
# 評価順番注意
idx += 5
else:
ok = False
break
if ok:
print("YES")
else:
print("NO")
if __name__ == '__main__':
main()
|
s296629631 | p03854 | u652737716 | 1501637020 | Python | Python (3.4.3) | py | Runtime Error | 177 | 134396 | 459 | import sys
S = input()
while S:
prefix = S[0:5]
if prefix == 'dream':
if S[5:7] == 'er':
if len(S) >= 8 and S[7] == 'a':
S = S[5:]
else:
S = S[7:]
else:
S = S[5:]
elif prefix == 'erase':
if len(S) >= 6 and S[5] == 'r':
S = S[6:]
else:
S = S[5:]
else:
print('NO')
sys.exit(0)
print(S)
print('YES')
|
s458241190 | p03854 | u652737716 | 1501636814 | Python | Python (3.4.3) | py | Runtime Error | 68 | 3188 | 444 | import sys
S = input()
while S:
prefix = S[0:5]
if prefix == 'dream':
if S[5:7] == 'er':
if len(S) > 8 and S[7] == 'a':
S = S[5:]
else:
S = S[7:]
else:
S = S[5:]
elif prefix == 'erase':
if S[5] == 'r':
S = S[6:]
else:
S = S[5:]
else:
print('NO')
sys.exit(0)
# print(S)
print('YES')
|
s543172931 | p03854 | u652737716 | 1501636739 | Python | Python (3.4.3) | py | Runtime Error | 68 | 3188 | 429 | import sys
S = input()
while S:
prefix = S[0:5]
if prefix == 'dream':
if S[5:7] == 'er':
if S[7] == 'a':
S = S[5:]
else:
S = S[7:]
else:
S = S[5:]
elif prefix == 'erase':
if S[5] == 'r':
S = S[6:]
else:
S = S[5:]
else:
print('NO')
sys.exit(0)
# print(S)
print('YES')
|
s431358455 | p03854 | u841907810 | 1492546443 | Python | Python (2.7.6) | py | Runtime Error | 10 | 2568 | 2542 | import java.lang.*;
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws java.lang.Exception {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(in, out);
out.close();
}
}
class TaskA {
public void solve(InputReader in, PrintWriter out) {
final String dream = "dream";
final String dreamer = "dreamer";
final String erase = "erase";
final String eraser = "eraser";
final int dreamLen = dream.length();
final int dreamerLen = dreamer.length();
final int eraseLen = erase.length();
final int eraserLen = eraser.length();
final String s = in.next();
final int slen = s.length();
int i = 0, j;
char ch;
while (i < slen) {
ch = s.charAt(i);
if (ch!='d' && ch!='e') {
out.println("NO");
return;
}
boolean flag = false;
if (ch == 'e') {
if (i+eraserLen <= slen) {
if (eraser.equals(s.substring(i, i+eraserLen))) {
flag = true;
i += eraserLen;
}
}
if (!flag && i+eraseLen <= slen) {
if (erase.equals(s.substring(i, i+eraseLen))) {
flag = true;
i += eraseLen;
}
}
} else {
if (i+dreamerLen<=slen && dreamer.equals(s.substring(i, i+dreamerLen))) {
flag = true;
if (i+dreamLen+eraseLen<=slen && erase.equals(s.substring(i+dreamLen, i+dreamLen+eraseLen))) {
i += dreamLen;
} else {
i += dreamerLen;
}
} else if (i+dreamLen<=slen && dream.equals(s.substring(i, i+dreamLen))) {
flag = true;
i += dreamLen;
}
}
if (!flag) {
out.println("NO");
return ;
}
}
if (i == slen)
out.println("YES");
else
out.println("NO");
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer==null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
|
s176496337 | p03854 | u432042540 | 1492011288 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3316 | 524 | s = input()
# t = ['dream', 'dreamer', 'erase', 'eraser']
s = s[::-1]
for i in range(4):
t[i] = t[i][::-1]
# print(s,t)
tmp = s
while tmp != '':
d = tmp[:5] == 'maerd'
dr = tmp[:7] == 'remaerd'
e = tmp[:5] == 'esare'
er = tmp[:6] == 'resare'
# print(tmp[:5])
# print(d,dr,e,er)
if d:
tmp = tmp[5:]
elif e:
tmp = tmp[5:]
elif dr:
tmp = tmp[7:]
elif er:
tmp = tmp[6:]
else:
print('NO')
break
if tmp == '':
print('YES')
|
s488119986 | p03854 | u484412230 | 1490916774 | Python | Python (3.4.3) | py | Runtime Error | 124 | 98616 | 722 | input = input()
# 前から一意に分解することができないので, 後ろから分解していくことになる
reversed_str = input[::-1]
dream = 'dream'
dreamer = 'dreamer'
erase = 'erase'
eraser = 'eraser'
dream = dream[::-1]
dreamer = dreamer[::-1]
erase = erase[::-1]
eraser = eraser[::-1]
def check(str):
if str == '':
return True
if len(str) < 5:
return False
if str[0:5] == dream or str[0:5] == erase:
check(str[5:])
return True
elif str[0:6] == eraser:
check(str[6:])
return True
elif str[0:7] == dreamer:
check(str[7:])
return True
return False
if check(reversed_str):
print('YES')
else:
print('NO') |
s846499492 | p03854 | u484412230 | 1490916324 | Python | Python (3.4.3) | py | Runtime Error | 137 | 98624 | 1195 | input = input()
"""
def check(str):
# 終了条件が分からない
str0 = str + 'dream'
str1 = str + 'dreamer'
str2 = str + 'erase'
str3 = str + 'eraser'
print(str)
if str0 == input or str1 == input or str2 == input or str3 == input:
return True
check(str0)
check(str1)
check(str2)
check(str3)
return False
if check(''):
print('YES')
else:
print('NO')
# 再帰が深いとダメになる
"""
# 前から一意に分解することができないので, 後ろから分解していくことになる
reversed_str = input[::-1]
dream = 'dream'
dreamer = 'dreamer'
erase = 'erase'
eraser = 'eraser'
dream = dream[::-1]
dreamer = dreamer[::-1]
erase = erase[::-1]
eraser = eraser[::-1]
def check(str):
if str == '':
return True
if len(str) < 5:
return False
if str[0:5] == dream or str[0:5] == erase:
if check(str[5:]):
return True
elif str[0:6] == eraser:
if check(str[6:]):
return True
elif str[0:7] == dreamer:
if check(str[7:]):
return True
return False
if check(reversed_str):
print('YES')
else:
print('NO') |
s004772024 | p03854 | u338686846 | 1487799948 | Python | Python (2.7.6) | py | Runtime Error | 11 | 2692 | 171 | S = raw_input()
S = S.strip("dream", "")
S = S.strip("dreamer", "")
S = S.strip("erase", "")
S = S.strip("eraser", "")
if len(S)==0:
print 'YES'
else:
print 'NO'
|
s348575842 | p03854 | u010110540 | 1487008688 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3064 | 221 | l = ['dream', 'dreamer', 'erase', 'eraser']
S = input()
while len(S) > 0:
flag = False
for d in l:
if S.endswith(d):
S = S[:-len(d)]
flag = True
break
if flag = False:
print('NO')
exit()
print('YES') |
s816162644 | p03854 | u012694084 | 1485025444 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3188 | 285 | words = ("dream", "erase", "eraser", "dreamer")
s = input()
while len(s) > 0:
match = False
for w in words:
if s.endwith(w):
s = s[:-len(w)]
match = True
break
if match is False:
print("NO")
exit()
print("YES")
|
s176263284 | p03854 | u386131832 | 1482426274 | Python | Python (3.4.3) | py | Runtime Error | 1838 | 6976 | 254 | import sys
def DFS(list,s,t):
if s==t:
print("YES")
sys.exit()
if not t in s:
return
for i in list:
DFS(list,s,t+i)
list=["maerd","remaerd","esare","resare"]
s=input()
s=s[::-1]
t=""
DFS(list,s,t)
print("NO") |
s209287187 | p03854 | u674122790 | 1482026960 | Python | Python (2.7.6) | py | Runtime Error | 16 | 2692 | 498 | s = raw_input(); i = 0; d = 1
# dreamerase eraser
while i < len(s):
if s.startswith(i,i+len('dreamerase')):
i += len('dreamerase')
elif s.startswith(i,i+len('dreameraser')):
i += len('dreameraser')
elif s.startswith(i,i+len('dream')):
i += len('dream')
elif s.startswith(i,i+len('dreamer')):
i += len('dreamer')
elif s.startswith(i,i+len('erase')):
i += len('erase')
elif s.startswith(i,i+len('eraser')):
i += len('eraser')
else:
d = 0
if d == 1:
print 'YES'
else:
print 'NO' |
s902923824 | p03854 | u733353761 | 1481849097 | Python | Python (3.4.3) | py | Runtime Error | 235 | 98628 | 299 | #cording : utf-8
strset = ["dream","dreamer","erase","eraser"]
def check(str):
if str is "":
return True
for s in strset:
if str.startswith(s):
if check(str.split(s,1)[1]):
return True
return False
print("YES" if check(input()) else "NO")
|
s259269041 | p03854 | u317493066 | 1481607245 | Python | Python (3.4.3) | py | Runtime Error | 24 | 3316 | 387 | # -*- coding:utf-8 -*-
DREAM = "dream"
DREAMER = "dreamer"
ERASE = "erase"
ERASER = "eraser"
text = input()
while(len(text) > 0):
if text[-5:] == DREAM:
text = text[:-5]
elif text[-6:] == DREAMER:
text = text[:-6]
elif text[-5:] == ERASE:
text = text[:-5]
else:
text = text[-6]
if len(text) == 0:
print("YES")
break
|
s949950457 | p03854 | u317493066 | 1481607177 | Python | Python (3.4.3) | py | Runtime Error | 22 | 3068 | 368 | # -*- coding:utf-8 -*-
DREAM = "dream"
DREAMER = "dreamer"
ERASE = "erase"
ERASER = "eraser"
text = input()
while(len(text):
if text[-5:] == DREAM:
text = text[:-5]
elif text[-6:] == DREAMER:
text = text[:-6]
elif text[-5:] == ERASE:
text = text[:-5]
else:
text = text[-6]
if len(text) == 0:
print("YES")
|
s848919374 | p03854 | u582243208 | 1481428089 | Python | Python (3.4.3) | py | Runtime Error | 23 | 3192 | 141 | a=["eraser","erase","dreamer","dream"]
s=input()
for i in range(4):
s=s.replace(a[i],"")
if s="":
print("YES")
else:
print("NO") |
s314218079 | p03854 | u096190786 | 1481426981 | Python | Python (2.7.6) | py | Runtime Error | 165 | 98172 | 561 | #!/usr/bin/python
import re
import sys
TOKENS = ["dream", "dreamer", "erase", "eraser"]
def check(s):
if s in TOKENS:
return "YES"
else:
if len(s) > 5 and s[-5:] in [TOKENS[0], TOKENS[2]]:
return check(s[0:-5])
elif len(s) > 6 and s[-6:] == TOKENS[3]:
return check(s[0:-6])
elif len(s) > 7 and s[-7:] == TOKENS[1]:
return check(s[0:-7])
return "NO"
def main(argv):
for line in sys.stdin:
print check(line.rstrip("\n"))
if __name__ == "__main__":
main(sys.argv) |
s579253402 | p03855 | u137226361 | 1600235536 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 33672 | 1007 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
root_x = find(x, par)
root_y = find(y, par)
if root_y > root_x:
par[root_x] = root_y
else:
par[root_y] = root_x
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
find(q-1, par)
unite(p-1, q-1)
#print(par)
root =[find(i, par) for i in range(N)]
#print(root)
#find(0,par)
#print(par)
for _ in range(L):
p, q = map(int, input().split())
s = root[p-1]
t = root[q-1]
if s == t:
unite2(p-1, q-1)
#print(par2)
for i in range(N-1):
p = find(i, par2)
print(size[p], end=' ')
print(size[find(N-1, par2)]) |
s372885073 | p03855 | u137226361 | 1600235307 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 43616 | 572 | from collections import Counter
n,k,l=map(int,input().split())
city1=[i for i in range(n)]
city2=[i for i in range(n)]
def root(c,x):
if x==c[x]:
return x
else:
return root(c,c[x])
def union(c,x,y):
rx=root(c,x)
ry=root(c,y)
c[rx]=ry
for i in range(k):
a,b=map(int,input().split())
union(city1,a-1,b-1)
for i in range(l):
a,b=map(int,input().split())
union(city2,a-1,b-1)
r=[]
for i in range(n):
r.append((root(city1,i),root(city2,i)))
c=Counter(r)
for i in range(n):
ans=c[r[i]]
if i==n-1:
print(ans)
else:
print(ans,end=' ') |
s131406784 | p03855 | u137226361 | 1600235120 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 26624 | 597 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
root_x = find(x, par)
root_y = find(y, par)
par[root_x] = root_y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
find(q-1, par)
unite(p-1, q-1) |
s011500855 | p03855 | u137226361 | 1600232996 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 26700 | 695 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
root_x = find(x, par)
root_y = find(y, par)
if root_x != root_y:
# xとyの属している集合が異なる時
pass
par[root_x] = root_y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
find(q-1, par)
unite(p-1, q-1) |
s647382219 | p03855 | u137226361 | 1600232761 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 26720 | 665 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
pass
par[x] = y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
find(q-1, par)
unite(p-1, q-1) |
s395015795 | p03855 | u137226361 | 1600232593 | Python | Python (3.8.2) | py | Runtime Error | 231 | 25964 | 629 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
par[x] = y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
find(q, par) |
s166579128 | p03855 | u137226361 | 1600232359 | Python | Python (3.8.2) | py | Runtime Error | 2205 | 26696 | 632 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
par[x] = y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
unite(p-1, q-1) |
s784290067 | p03855 | u137226361 | 1600232281 | Python | Python (3.8.2) | py | Runtime Error | 2205 | 26840 | 686 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
par[x] = y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
unite(p-1, q-1)
#print(par)
root =[find(i, par) for i in range(N)] |
s760793849 | p03855 | u137226361 | 1600231918 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 26700 | 979 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, P):
if P[x] == x:
return x
else:
return find(P[x], P)
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
par[x] = y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
unite(p-1, q-1)
#print(par)
root =[find(i, par) for i in range(N)]
#print(root)
#find(0,par)
#print(par)
for _ in range(L):
p, q = map(int, input().split())
s = root[p-1]
t = root[q-1]
if s == t:
unite2(p-1, q-1)
#print(par2)
for i in range(N-1):
p = find(i, par2)
print(size[p], end=' ')
print(size[find(N-1, par2)]) |
s498938889 | p03855 | u137226361 | 1600229267 | Python | Python (3.8.2) | py | Runtime Error | 583 | 26324 | 935 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
def find(x, par):
if par[x] == x:
return x
else:
par[x] == find(par[x], par)
return par[x]
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
par[x] = y
par2 = [i for i in range(N)]
def unite2(x: object, y: object) -> object:
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
unite(p-1, q-1)
for _ in range(L):
p, q = map(int, input().split())
s = find(p-1, par)
t = find(q-1, par)
if s==t:
unite2(p-1, q-1)
for i in range(N-1):
p = find(i, par2)
print(size[p], end=' ')
print(size[find(N-1, par2)]) |
s678929487 | p03855 | u137226361 | 1600188967 | Python | Python (3.8.2) | py | Runtime Error | 2206 | 28448 | 868 | N, K, L = map(int, input().split())
par = [i for i in range(N)]
size = [1] * N
rank = [1] * N
def find(x, par):
if par[x] == x:
return x
else:
return find(par[x], par)
def unite(x, y):
x = find(x, par)
y = find(y, par)
if x != y:
# xとyの属している集合が異なる時
par[x] = y
par2 = [i for i in range(N)]
def unite2(x, y):
x = find(x, par2)
y = find(y, par2)
if x != y:
# xとyの属している集合が異なる時
par2[x] = y
s = size[x] + size[y]
size[y] = s
for _ in range(K):
p, q = map(int, input().split())
unite(p-1, q-1)
for _ in range(L):
p, q = map(int, input().split())
s = find(p-1, par)
t = find(q-1, par)
if s==t:
unite2(p-1, q-1)
for i in range(N):
p = find(i, par2)
print(size[p], end=' ')
|
s004993650 | p03855 | u074220993 | 1599175436 | Python | Python (3.8.2) | py | Runtime Error | 50 | 24496 | 598 | N, K, L = map(int, input().split())
#Parent List(PL)
road = [i for i in range(N)]
rail = [i for i in range(N)]
def fp(x,P): #findParent
if x == P[x]:
return x
else:
P[x] = fp(P[x])
return P[x]
for i in range(K+L):
PL = (lambda x:road if x < K else rail)(i)
p, q = map(lambda x:int(x)-1, input().split())
p, q = fp(p,PL), fp(q,PL)
PL[p] = PL[q] = min(p, q)
from collections import defaultdict as dd
Wconnected = dd(lambda:0)
for i in range(N):
Wconnected[fp(i,road),fp(i,rail)] += 1
print(*[Wconnected[fp(i,road),fp(i,rail)] for i in range(N)]) |
s922971733 | p03855 | u682672120 | 1598467890 | Python | PyPy3 (7.3.0) | py | Runtime Error | 553 | 83148 | 851 | n, k, l = map(int, input().split())
roads = list(range(n))
railways = list(range(n))
ans = []
for _ in range(k):
a, b = map(lambda x : int(x) - 1, input().split())
i = min(roads[a], roads[b])
roads[roads[a]], roads[a] = i, i
roads[roads[b]], roads[b] = i, i
for _ in range(l):
a, b = map(lambda x : int(x) - 1, input().split())
i = min(railways[a], railways[b])
railways[railways[a]], railways[a] = i, i
railways[railways[b]], railways[b] = i, i
roads_dic = dict()
railways_dic = dict()
for i in range(n):
if roads[i] == i:
roads_dic[i] = {i}
else:
roads_dic[roads[i]].add(i)
if railways[i] == i:
railways_dic[i] = {i}
else:
railways_dic[railways[i]].add(i)
ans = [len(roads_dic[roads[i]] & railways_dic[railways[i]]) for i in range(n)]
print(" ".join(map(str, ans))) |
s325644903 | p03855 | u682672120 | 1598467075 | Python | PyPy3 (7.3.0) | py | Runtime Error | 510 | 83172 | 843 | n, k, l = map(int, input().split())
roads = list(range(n))
railways = list(range(n))
ans = []
for _ in range(k):
a, b = map(lambda x : int(x) - 1, input().split())
i = min(roads[a], roads[b])
roads[roads[a]] = roads[a] = i
roads[roads[b]] = roads[b] = i
for _ in range(l):
a, b = map(lambda x : int(x) - 1, input().split())
i = min(railways[a], railways[b])
railways[railways[a]] = railways[a] = i
railways[railways[b]] = railways[b] = i
roads_dic = dict()
railways_dic = dict()
for i in range(n):
if roads[i] == i:
roads_dic[i] = {i}
else:
roads_dic[roads[i]].add(i)
if railways[i] == i:
railways_dic[i] = {i}
else:
railways_dic[railways[i]].add(i)
ans = [len(roads_dic[roads[i]] & railways_dic[railways[i]]) for i in range(n)]
print(" ".join(map(str, ans))) |
s850746534 | p03855 | u682672120 | 1598466897 | Python | PyPy3 (7.3.0) | py | Runtime Error | 533 | 83324 | 1110 | n, k, l = map(int, input().split())
roads = list(range(n))
railways = list(range(n))
ans = []
for _ in range(k):
a, b = map(lambda x : int(x) - 1, input().split())
i = min(roads[a], roads[b])
roads[roads[a]] = roads[a] = i
roads[roads[b]] = roads[b] = i
for _ in range(l):
a, b = map(lambda x : int(x) - 1, input().split())
i = min(railways[a], railways[b])
railways[railways[a]] = railways[a] = i
railways[railways[b]] = railways[b] = i
roads_dic = dict()
railways_dic = dict()
for i in range(n):
if roads[i] == i and not i in roads_dic:
roads_dic[i] = {i}
elif not roads[roads[i]] in roads_dic:
roads_dic[roads[roads[i]]] = {i, roads[i]}
else:
roads_dic[roads[i]].add(i)
if railways[i] == i and not i in railways_dic:
railways_dic[i] = {i}
elif not railways[railways[i]] in railways_dic:
railways_dic[railways[railways[i]]] = {i, railways[i]}
else:
railways_dic[railways[i]].add(i)
ans = [len(roads_dic[roads[i]] & railways_dic[railways[i]]) for i in range(n)]
print(" ".join(map(str, ans))) |
s046751781 | p03855 | u756464404 | 1597757557 | Python | Python (3.8.2) | py | Runtime Error | 2207 | 52692 | 822 | import sys
import numpy as np
input = sys.stdin.readline
def main():
n, k, l = map(int, input().split())
road_matrix = np.identity(n, dtype='bool')
train_matrix = np.identity(n, dtype='bool')
for _ in range(k):
p, q = map(int, input().split())
p, q = p-1, q-1
road_matrix[p][q] = 1
road_matrix[q][p] = 1
for _ in range(l):
r, s = map(int, input().split())
r, s = r-1, s-1
train_matrix[r][s] = 1
train_matrix[s][r] = 1
r = search(road_matrix)
t = search(train_matrix)
cnt_arr = np.sum(r & t, axis=1)
print(' '.join(map(str,cnt_arr)))
def search(matrix):
result = np.copy(matrix)
while True:
tmp = np.dot(result, matrix)
if (tmp == result).all:
result = tmp
break
result = tmp
return result
if __name__ == '__main__':
main() |
s915703560 | p03855 | u074220993 | 1597206000 | Python | Python (3.8.2) | py | Runtime Error | 25 | 8948 | 1397 | #include<bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
long set_index;
void dfs(Graph graph, vector<bool>& seen, vector<int>& set, int v){
seen[v] = true;
set[v] = set_index;
for (auto next_v : graph[v]){
if (seen[next_v]) continue;
dfs(graph, seen, set, next_v);
}
}
void input(Graph& graph, int M){
int p, q;
for (int i=0; i<M; i++){
cin >> p >> q;
graph[p-1].push_back(q-1);
graph[q-1].push_back(p-1);
}
}
void connect(Graph& graph, vector<bool>& seen, vector<int>& set, int n){
set_index = 0;
for (int v=0; v<n; v++){
if (seen[v]) continue;
dfs(graph, seen, set, v);
set_index++;
}
}
int main(){
int N, K, L;
cin >> N >> K >> L;
Graph road, rail;
vector<bool> seen_road, seen_rail;
vector<int> set_road, set_rail;
road.resize(N);
rail.resize(N);
set_road.assign(N, 0);
set_rail.assign(N, 0);
input(road, K);
input(rail, L);
seen_road.assign(N, false);
connect(road, seen_road, set_road, N);
seen_rail.assign(N, false);
connect(rail, seen_rail, set_rail, N);
map<pair<long, long>, int> ans;
for (int i=0; i<N; i++){
ans[make_pair(set_road[i],set_rail[i])]++;
}
for (int i=0; i<N; i++){
cout << ans[make_pair(set_road[i],set_rail[i])] << " ";
}
return 0;
} |
s129218142 | p03855 | u074220993 | 1597204190 | Python | Python (3.8.2) | py | Runtime Error | 1585 | 176152 | 1003 | N, K, L = map(int, input().split())
road = [{"Connected":[],"seen":False,"set":0} for _ in range(N)]
rail = [{"Connected":[],"seen":False,"set":0} for _ in range(N)]
def dfs(graph, v, index): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = index
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, index)
for X in ((road, K), (rail, L)): #結合を入力
for _ in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in (road, rail): #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
dfs(X, v, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
D = {}
for X in List:
if not X in D:
D[X] = 1
else:
D[X] += 1
for A in List:
print(D[A],end=" ")
|
s850043782 | p03855 | u074220993 | 1597203330 | Python | Python (3.8.2) | py | Runtime Error | 1569 | 177984 | 984 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"seen":False,"set":0} for _ in range(200000)]
rail = [{"Connected":[],"seen":False,"set":0} for _ in range(200000)]
def dfs(graph, v, index): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = index
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, index)
for X in ((road, K), (rail, L)): #結合を入力
for _ in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in (road, rail): #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
dfs(X, v, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
count = collections.Counter(List)
for A in List:
print(count[A],end=" ")
|
s740774940 | p03855 | u074220993 | 1597202863 | Python | Python (3.8.2) | py | Runtime Error | 1595 | 176384 | 992 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"seen":False,"set":0} for _ in range(N)]
rail = [{"Connected":[],"seen":False,"set":0} for _ in range(N)]
def dfs(graph, v, index): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = index
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, index)
for X in ((road, K), (rail, L)): #結合を入力
for _ in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in (road, rail): #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
dfs(X, v, set_index)
set_index += 1
del set_index
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
count = collections.Counter(List)
for A in List:
print(count[A],end=" ")
|
s120647723 | p03855 | u074220993 | 1597202375 | Python | Python (3.8.2) | py | Runtime Error | 1599 | 176248 | 976 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"seen":False,"set":-1} for _ in range(N)]
rail = [{"Connected":[],"seen":False,"set":-1} for _ in range(N)]
def dfs(graph, v, index): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = index
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, index)
for X in ((road, K), (rail, L)): #結合を入力
for _ in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in (road, rail): #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
dfs(X, v, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
count = collections.Counter(List)
for A in List:
print(count[A],end=" ")
|
s592727687 | p03855 | u074220993 | 1597201715 | Python | Python (3.8.2) | py | Runtime Error | 1547 | 176444 | 958 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"seen":False} for _ in range(N)]
rail = [{"Connected":[],"seen":False} for _ in range(N)]
def dfs(graph, v, index): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = index
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, index)
for X in ((road, K), (rail, L)): #結合を入力
for _ in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in (road, rail): #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
dfs(X, v, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
count = collections.Counter(List)
for A in List:
print(count[A],end=" ")
|
s990453435 | p03855 | u074220993 | 1597168974 | Python | Python (3.8.2) | py | Runtime Error | 1684 | 177060 | 978 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"set":0,"seen":False} for _ in range(N)]
rail = [{"Connected":[],"set":0,"seen":False} for _ in range(N)]
def dfs(graph, v, num): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = num
for next_v in set(graph[v]["Connected"]):
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, num)
for X in ((road, K), (rail, L)): #結合を入力
for _ in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in [road, rail]: #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
dfs(X, v, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s072131589 | p03855 | u074220993 | 1597168533 | Python | Python (3.8.2) | py | Runtime Error | 1659 | 176392 | 977 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"set":0,"seen":False} for _ in range(N+1)]
rail = [{"Connected":[],"set":0,"seen":False} for _ in range(N+1)]
def dfs(graph, v, num): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = num
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, num)
for X in ((road, K), (rail, L)): #結合を入力
for i in range(X[1]):
p, q = map(int, input().split())
X[0][p]["Connected"].append(q)
X[0][q]["Connected"].append(p)
for X in [road, rail]: #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v+1]["seen"]:
continue
set_index += 1
dfs(X, v+1, set_index)
List = [(road[i+1]["set"],rail[i+1]["set"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s712780586 | p03855 | u074220993 | 1597168389 | Python | Python (3.8.2) | py | Runtime Error | 1581 | 176284 | 973 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"set":0,"seen":False} for _ in range(N)]
rail = [{"Connected":[],"set":0,"seen":False} for _ in range(N)]
def dfs(graph, v, num): #深さ優先探索
graph[v]["seen"] = True
graph[v]["set"] = num
for next_v in graph[v]["Connected"]:
if graph[next_v]["seen"]:
continue
dfs(graph, next_v, num)
for X in ((road, K), (rail, L)): #結合を入力
for i in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(q-1)
X[0][q-1]["Connected"].append(p-1)
for X in [road, rail]: #探索して連結成分に分解
set_index = 0
for v in range(N):
if X[v]["seen"]:
continue
set_index += 1
dfs(X, v, set_index)
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s808992891 | p03855 | u074220993 | 1597168012 | Python | Python (3.8.2) | py | Runtime Error | 1540 | 167128 | 942 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"set":0,"seen":False} for _ in range(N)]
rail = [{"Connected":[],"set":0,"seen":False} for _ in range(N)]
def dfs(node, num): #深さ優先探索
node["seen"] = True
node["set"] = num
for next_node in node["Connected"]:
if next_node["seen"]:
continue
dfs(next_node, num)
for X in ((road, K), (rail, L)): #結合を入力
for i in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(X[0][q-1])
X[0][q-1]["Connected"].append(X[0][p-1])
for X in [road, rail]: #探索して連結成分に分解
set_index = 0
for x in X:
if x["seen"]:
continue
dfs(x, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s334071676 | p03855 | u074220993 | 1597167455 | Python | Python (3.8.2) | py | Runtime Error | 1592 | 167036 | 952 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"set":-1,"seen":False} for i in range(N)]
rail = [{"Connected":[],"set":-1,"seen":False} for i in range(N)]
def dfs(node, num): #深さ優先探索
node["seen"] = True
node["set"] = num
for next_node in node["Connected"]:
if next_node["seen"]:
continue
dfs(next_node, num)
for X in ((road, K), (rail, L)): #結合を入力
for i in range(X[1]):
p, q = map(int, input().split())
X[0][p-1]["Connected"].append(X[0][q-1])
X[0][q-1]["Connected"].append(X[0][p-1])
for X in [road, rail]: #探索して連結成分に分解
set_index = 0
for x in X:
if x["seen"]:
continue
dfs(x, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s179746303 | p03855 | u074220993 | 1597167063 | Python | Python (3.8.2) | py | Runtime Error | 1559 | 167092 | 1007 | import collections
N, K, L = map(int, input().split())
road = [{"Connected":[],"set":-1,"seen":False} for i in range(N)]
rail = [{"Connected":[],"set":-1,"seen":False} for i in range(N)]
def dfs(node, num): #深さ優先探索
node["seen"] = True
node["set"] = num
for next_node in node["Connected"]:
if next_node["seen"]:
continue
dfs(next_node, num)
for i in range(K):
p, q = map(int, input().split())
road[p-1]["Connected"].append(road[q-1])
road[q-1]["Connected"].append(road[p-1])
for i in range(L):
r, s = map(int, input().split())
rail[r-1]["Connected"].append(rail[s-1])
rail[s-1]["Connected"].append(rail[r-1])
for X in [road, rail]: #連結成分に分解
set_index = 0
for x in X:
if x["seen"]:
continue
dfs(x, set_index)
set_index += 1
List = [(road[i]["set"],rail[i]["set"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s105664243 | p03855 | u074220993 | 1597166072 | Python | Python (3.8.2) | py | Runtime Error | 2211 | 221748 | 1094 | import collections
N, K, L = map(int, input().split())
city = [{"road":{"Connected":[],"set":-1,"seen":False},
"rail":{"Connected":[],"set":-1,"seen":False}} for i in range(N)]
def dfs(graph, v, way, num): #深さ優先探索
graph[v][way]["seen"] = True
graph[v][way]["set"] = num
for next_v in graph[v][way]["Connected"]:
if graph[next_v][way]["seen"]:
continue
dfs(graph, next_v, way, num)
for i in range(K):
p, q = map(int, input().split())
city[p-1]["road"]["Connected"].append(q-1)
city[q-1]["road"]["Connected"].append(p-1)
for i in range(L):
r, s = map(int, input().split())
city[r-1]["rail"]["Connected"].append(s-1)
city[s-1]["rail"]["Connected"].append(r-1)
for X in ["road", "rail"]: #連結成分に分解
set_index = 0
for v in range(N):
if city[v][X]["seen"]:
continue
dfs(city, v, X, set_index)
set_index += 1
List = [(x["road"]["set"],x["rail"]["set"]) for x in city]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s949217442 | p03855 | u074220993 | 1597165118 | Python | Python (3.8.2) | py | Runtime Error | 2210 | 236600 | 1040 | import collections
N, K, L = map(int, input().split())
city = [{"road":{"Connected":[i],"set":-1,"seen":False},
"rail":{"Connected":[i],"set":-1,"seen":False}} for i in range(N)]
def dfs(graph, v, way, num):
graph[v][way]["seen"] = True
graph[v][way]["set"] = num
for next_v in graph[v][way]["Connected"]:
if graph[next_v][way]["seen"]:
continue
dfs(graph, next_v, way, num)
for i in range(K):
p, q = map(int, input().split())
city[p-1]["road"]["Connected"].append(q-1)
city[q-1]["road"]["Connected"].append(p-1)
for i in range(L):
r, s = map(int, input().split())
city[r-1]["rail"]["Connected"].append(s-1)
city[s-1]["rail"]["Connected"].append(r-1)
for X in ["road", "rail"]:
count = 0
for v in range(N):
if city[v][X]["seen"]:
continue
dfs(city, v, X, count)
count += 1
List = [(x["road"]["set"],x["rail"]["set"]) for x in city]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s357043216 | p03855 | u074220993 | 1597164568 | Python | Python (3.8.2) | py | Runtime Error | 2213 | 236408 | 1066 | import collections
N, K, L = map(int, input().split())
city = [{"road":{"Connected":[i],"group":-1,"seen":False},
"rail":{"Connected":[i],"group":-1,"seen":False}} for i in range(N)]
def dfs(graph, v, way, num):
graph[v][way]["seen"] = True
graph[v][way]["group"] = num
for next_v in graph[v][way]["Connected"]:
if graph[next_v][way]["seen"]:
continue
dfs(graph, next_v, way, num)
for i in range(K):
p, q = map(int, input().split())
city[p-1]["road"]["Connected"].append(q-1)
city[q-1]["road"]["Connected"].append(p-1)
for i in range(L):
r, s = map(int, input().split())
city[r-1]["rail"]["Connected"].append(s-1)
city[s-1]["rail"]["Connected"].append(r-1)
for X in ["road", "rail"]:
count = 0
for v in range(N):
if city[v][X]["seen"]:
continue
dfs(city, v, X, count)
count += 1
List = [(city[i]["road"]["group"],city[i]["rail"]["group"]) for i in range(N)]
counter = collections.Counter(List)
for A in List:
print(counter[A],end=" ")
|
s928601601 | p03855 | u074220993 | 1597164000 | Python | Python (3.8.2) | py | Runtime Error | 2212 | 236548 | 1055 | import collections
N, K, L = map(int, input().split())
city = [{"road":{"Connected":[i],"seen":-1}, "rail":{"Connected":[i],"seen":-1}} for i in range(N)]
def dfs(graph, v, way, num):
graph[v][way]["seen"] = num
for next_v in graph[v][way]["Connected"]:
if graph[next_v][way]["seen"] >= 0:
continue
dfs(graph, next_v, way, num)
for i in range(K):
p, q = map(int, input().split())
city[p-1]["road"]["Connected"].append(q-1)
city[q-1]["road"]["Connected"].append(p-1)
for i in range(L):
r, s = map(int, input().split())
city[r-1]["rail"]["Connected"].append(s-1)
city[s-1]["rail"]["Connected"].append(r-1)
for X in ["road", "rail"]:
count = 0
for v in range(N):
if city[v][X]["seen"] >= 0:
continue
dfs(city, v, X, count)
count += 1
List = [(city[i]["road"]["seen"],city[i]["rail"]["seen"]) for i in range(N)]
counter = collections.Counter(List)
for i in range(N):
print(counter[(city[i]["road"]["seen"],city[i]["rail"]["seen"])],end=" ")
|
s579035082 | p03855 | u074220993 | 1597161328 | Python | Python (3.8.2) | py | Runtime Error | 2211 | 221600 | 1215 | N, K, L = map(int, input().split())
city = [{"road":{"Connected":[i],"seen":False}, "rail":{"Connected":[i],"seen":False}} for i in range(N)]
Connected_Components = {"road":list(),"rail":list()}
def dfs(graph, v, way, List):
graph[v][way]["seen"] = True
List.append(v)
for next_v in graph[v][way]["Connected"]:
if graph[next_v][way]["seen"] == True:
continue
dfs(graph, next_v, way, List)
for i in range(K):
p, q = map(int, input().split())
city[p-1]["road"]["Connected"].append(q-1)
city[q-1]["road"]["Connected"].append(p-1)
for i in range(L):
r, s = map(int, input().split())
city[r-1]["rail"]["Connected"].append(s-1)
city[s-1]["rail"]["Connected"].append(r-1)
for X in ["road", "rail"]:
count = 0
for v in range(N):
if city[v][X]["seen"] == True:
continue
Connected_Components[X].append(list())
dfs(city, v, X, Connected_Components[X][count])
for i in Connected_Components[X][count]:
city[i][X]["Connected"] = Connected_Components[X][count]
count += 1
for v in range(N):
print(len(set(city[v]["road"]["Connected"])&set(city[v]["rail"]["Connected"])), end=" ")
|
s618323531 | p03855 | u074220993 | 1597127363 | Python | Python (3.8.2) | py | Runtime Error | 33 | 10552 | 554 | N, K, L = map(int, input().split())
city = [1 for i in range(N)]
setA = set()
setB = set()
for i in range(K):
X = set(int(x)-1 for x in input().split())
for A in setA:
if A & X != set():
A = A | X
else:
setA.add(X)
for i in range(L):
Y = set(int(y)-1 for y in input().split())
for B in setB:
if B & Y != set():
B = B | Y
else:
setB.add(Y)
for A in setA:
for B in setB:
for i in A & B:
city[i] = len(A&B)
for i in range(N):
print(city[i], end=" ") |
s949264613 | p03855 | u730769327 | 1596376694 | Python | PyPy3 (7.3.0) | py | Runtime Error | 2213 | 224112 | 767 | def dfs(now,vis,e,j,el):
vis+=[now]
e[now]=j
res=set([now])
for to in el[now]:
if to in vis:continue
res=res|dfs(to,vis[:],e,j,el)
e[to]=j
return res
n,k,l=map(int,input().split())
el=[set() for _ in range(n+1)]
et=[set() for _ in range(n+1)]
ela=[set() for _ in range(n+1)]
eta=[set() for _ in range(n+1)]
eml=[0]*(n+1)
emt=[0]*(n+1)
ans=[0]*(n+1)
for _ in range(k):
p,q=map(int,input().split())
el[p].add(q)
el[q].add(p)
j=0
for i in range(n+1):
if eml[i]:continue
ela[j]=dfs(i,[],eml,j,el)
j+=1
for _ in range(l):
p,q=map(int,input().split())
et[p].add(q)
et[q].add(p)
j=0
for i in range(n+1):
if emt[i]:continue
eta[j]=dfs(i,[],emt,j,et)
j+=1
for i in range(n+1):
ans[i]=len(eta[emt[i]]&ela[eml[i]])
print(*ans[1:]) |
s456928215 | p03855 | u825955102 | 1595884110 | Python | PyPy3 (7.3.0) | py | Runtime Error | 773 | 179556 | 1193 | import collections
NO_OF_DIMENSIONS = 2
no_of_edges_by_dim = [0] * NO_OF_DIMENSIONS
n, no_of_edges_by_dim[0], no_of_edges_by_dim[1] = (int(x) for x in input().split())
graph_by_dimension = [[[] for _ in range(n + 1)] for _ in range(NO_OF_DIMENSIONS)]
for dimension, no_of_edges in enumerate(no_of_edges_by_dim):
graph = graph_by_dimension[dimension]
for _ in range(no_of_edges):
p, q = (int(x) for x in input().split())
graph[p].append(q)
graph[q].append(p)
components_ids_by_vertex = [[None] * NO_OF_DIMENSIONS for _ in range(n + 1)]
def dfs(dimension_id, vertex_id, colour):
components_ids_by_vertex[vertex_id][dimension_id] = colour
for s in graph_by_dimension[dimension_id][vertex_id]:
if not components_ids_by_vertex[s][dimension_id]:
dfs(dimension_id, s, colour)
for i in range(NO_OF_DIMENSIONS):
for j in range(1, n + 1):
if not components_ids_by_vertex[j][i]:
dfs(i, j, j)
components_ids_by_vertex = [tuple(x) for x in components_ids_by_vertex]
results = collections.Counter(components_ids_by_vertex)
for i in range(1, n + 1):
print(results[components_ids_by_vertex[i]], end=' ')
print()
|
s038742950 | p03855 | u786020649 | 1594755385 | Python | Python (3.8.2) | py | Runtime Error | 29 | 9076 | 2706 | import sys
from collections import deque
from collections import defaultdict
from collections import Counter
def conn(n,m,e):
d=dict(zip(range(1,n+1),range(-1,(-1)*n-1,-1)))
td=defaultdict(lambda:deque([])) #tdは同値類がキーで中の元が値
c=1
for edge in e:
a=edge[0]
b=edge[1]
da=d[a] #da,dbはa,bの含まれる同値流のラベル
db=d[b]
if da<0 and db<0:
d[a]=c
d[b]=c
td[c].append(a)
td[c].append(b)
c+=1
elif da>0 and db<0:
d[b]=da
td[d[a]].append(b)
elif da<0 and db>0:
d[a]=db
td[d[b]].append(a)
elif da>0 and db>0 and da!=db:
for x in td[db]:
d[x]=da
td[da].append(x)
return list(d.values())
def components(n,k,e):
ed=defaultdict(lambda:deque())
for edge in e:
ed[edge[0]].append(edge[1])
c=0
s=[0]*n
label=[0]*n
for i in range(1,n+1):
if s[i-1]==0:
c+=1
label[c-1]=c
stack=deque([i])
while stack:
w=stack.pop()
s[w-1]=c
while ed[w]:
wn=ed[w].pop()
if s[wn-1]==0:
s[wn-1]=c
if ed[wn]:
stack.append(w)
w=wn
elif s[wn-1]<c:
label[s[wn-1]-1]=c
return [label[s[i]-1] for i in range(n)]
def components2(n,k,e):
ed=defaultdict(lambda:deque())
for edge in e:
ed[edge[0]].append(edge[1])
ed[edge[1]].append(edge[0])
c=0
s=[0]*n
for i in range(1,n+1):
if s[i-1]==0:
c+=1
stack=deque([i])
while stack:
w=stack.pop()
s[w-1]=c
while ed[w]:
wn=ed[w].pop()
if s[wn-1]==0:
s[wn-1]=c
if ed[wn]:
stack.append(w)
w=wn
return [[s[i] for i in range(n)]
def main(n,k,l,e1,e2):
d1=components2(n,k,e1)
d2=components2(n,l,e2)
p=tuple(zip(iter(d1),iter(d2)))
d=Counter(p)
# print(d1,d2,d,p)
print(' '.join([str(d[x]) for x in p]))
if __name__=='__main__':
ssr=sys.stdin.readline
n,k,l=map(int,ssr().strip().split())
e1=[]
e2=[]
for _ in range(k):
e1.append(tuple(map(int,ssr().strip().split())))
for _ in range(l):
e2.append(tuple(map(int,ssr().strip().split())))
main(n,k,l,e1,e2)
|
s812404422 | p03855 | u786020649 | 1594755334 | Python | Python (3.8.2) | py | Runtime Error | 26 | 9092 | 2706 | import sys
from collections import deque
from collections import defaultdict
from collections import Counter
def conn(n,m,e):
d=dict(zip(range(1,n+1),range(-1,(-1)*n-1,-1)))
td=defaultdict(lambda:deque([])) #tdは同値類がキーで中の元が値
c=1
for edge in e:
a=edge[0]
b=edge[1]
da=d[a] #da,dbはa,bの含まれる同値流のラベル
db=d[b]
if da<0 and db<0:
d[a]=c
d[b]=c
td[c].append(a)
td[c].append(b)
c+=1
elif da>0 and db<0:
d[b]=da
td[d[a]].append(b)
elif da<0 and db>0:
d[a]=db
td[d[b]].append(a)
elif da>0 and db>0 and da!=db:
for x in td[db]:
d[x]=da
td[da].append(x)
return list(d.values())
def components(n,k,e):
ed=defaultdict(lambda:deque())
for edge in e:
ed[edge[0]].append(edge[1])
c=0
s=[0]*n
label=[0]*n
for i in range(1,n+1):
if s[i-1]==0:
c+=1
label[c-1]=c
stack=deque([i])
while stack:
w=stack.pop()
s[w-1]=c
while ed[w]:
wn=ed[w].pop()
if s[wn-1]==0:
s[wn-1]=c
if ed[wn]:
stack.append(w)
w=wn
elif s[wn-1]<c:
label[s[wn-1]-1]=c
return [label[s[i]-1] for i in range(n)]
def components2(n,k,e):
ed=defaultdict(lambda:deque())
for edge in e:
ed[edge[0]].append(edge[1])
ed[edge[1]].append[edge[0])
c=0
s=[0]*n
for i in range(1,n+1):
if s[i-1]==0:
c+=1
stack=deque([i])
while stack:
w=stack.pop()
s[w-1]=c
while ed[w]:
wn=ed[w].pop()
if s[wn-1]==0:
s[wn-1]=c
if ed[wn]:
stack.append(w)
w=wn
return [[s[i] for i in range(n)]
def main(n,k,l,e1,e2):
d1=components2(n,k,e1)
d2=components2(n,l,e2)
p=tuple(zip(iter(d1),iter(d2)))
d=Counter(p)
# print(d1,d2,d,p)
print(' '.join([str(d[x]) for x in p]))
if __name__=='__main__':
ssr=sys.stdin.readline
n,k,l=map(int,ssr().strip().split())
e1=[]
e2=[]
for _ in range(k):
e1.append(tuple(map(int,ssr().strip().split())))
for _ in range(l):
e2.append(tuple(map(int,ssr().strip().split())))
main(n,k,l,e1,e2)
|
s577473156 | p03855 | u072717685 | 1589146288 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 132596 | 2627 | import sys
input = sys.stdin.readline
road = {}
train = {}
node_seen = set()
road_belong_group = {}
train_belong_group = {}
road_group = {}
train_group = {}
def dfs_road(t_node, group_num):
global road_group, road_belong_group, node_seen
road_belong_group[t_node] = group_num
road_group[group_num].add(t_node)
node_seen.add(t_node)
next_nodes = set(road[t_node]) - node_seen
if len(next_nodes) == 0:
return
else:
for nextnr in next_nodes:
dfs_road(nextnr, group_num)
def dfs_train(t_node, group_num):
global node_seen, train_group, train_belong_group
train_belong_group[t_node] = group_num
train_group[group_num].add(t_node)
node_seen.add(t_node)
next_nodes = set(train[t_node]) - node_seen
if len(next_nodes) == 0:
return
else:
for nextnt in next_nodes:
dfs_train(nextnt, group_num)
def main():
global road, train, node_seen, road_group, train_group, node_all, road_belong_group,train_belong_group
# 入力
n, k, l = map(int, input().split())
#node_all = set([i for i in range(1, n + 1)])
road = {e: [] for e in range(1, n + 1)}
train = {e: [] for e in range(1, n + 1)}
road_belong_group = {e: -1 for e in range(1, n + 1)}
train_belong_group = {e: -1 for e in range(1, n + 1)}
for _ in range(k):
p, q = map(int, input().split())
road[p].append(q)
road[q].append(p)
for _ in range(l):
s, t = map(int, input().split())
train[s].append(t)
train[t].append(s)
# 処理
## 道路
group_num_road = 1
for i_road in range(1, n + 1):
if road_belong_group[i_road] != -1:
continue
if not road[i_road]:
continue
road_group[group_num_road] = set()
dfs_road(i_road, group_num_road)
group_num_road += 1
## 鉄道
node_seen = set([])
group_num_train = 1
for i_train in range(1, n + 1):
if train_belong_group[i_train] != -1:
continue
if not train[i_train]:
continue
train_group[group_num_train] = set()
dfs_train(i_train, group_num_train)
group_num_train += 1
# 出力
for i in range(1, n + 1):
rg = road_belong_group[i]
tg = train_belong_group[i]
if rg == -1 or tg == -1:
print(1, end= ' ')
else:
linked_city = len(road_group[rg].intersection(train_group[tg]))
if linked_city == 0:
linked_city += 1
print(linked_city, end = ' ')
if __name__ == '__main__':
main()
|
s817166188 | p03855 | u072717685 | 1589145866 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 132596 | 2628 | import sys
input = sys.stdin.readline
road = {}
train = {}
node_all = set()
node_seen = set()
road_belong_group = []
train_belong_group = []
road_group = {}
train_group = {}
def dfs_road(t_node, group_num):
global road_group, road_belong_group, node_seen
road_belong_group[t_node] = group_num
road_group[group_num].add(t_node)
node_seen.add(t_node)
next_nodes = set(road[t_node]) - node_seen
if len(next_nodes) == 0:
return
else:
for nextn in next_nodes:
dfs_road(nextn, group_num)
def dfs_train(t_node, group_num):
global node_seen, train_group, train_belong_group
train_belong_group[t_node] = group_num
train_group[group_num].add(t_node)
node_seen.add(t_node)
next_nodes = set(train[t_node]) - node_seen
if len(next_nodes) == 0:
return
else:
for nextn in next_nodes:
dfs_train(nextn, group_num)
def main():
global road, train, node_seen, road_group, train_group, node_all, road_belong_group,train_belong_group
# 入力
n, k, l = map(int, input().split())
#node_all = set([i for i in range(1, n + 1)])
road = {e: [] for e in range(1, n + 1)}
train = {e: [] for e in range(1, n + 1)}
road_belong_group = {e: -1 for e in range(1, n + 1)}
train_belong_group = {e: -1 for e in range(1, n + 1)}
for _ in range(k):
p, q = map(int, input().split())
road[p].append(q)
road[q].append(p)
for _ in range(l):
s, t = map(int, input().split())
train[s].append(t)
train[t].append(s)
# 処理
## 道路
group_num_road = 1
for i_road in range(1, n + 1):
if road_belong_group[i_road] != -1:
continue
if not road[i_road]:
continue
road_group[group_num_road] = set()
dfs_road(i_road, group_num_road)
group_num_road += 1
## 鉄道
node_seen = set([])
group_num_train = 1
for i_train in range(1, n + 1):
if train_belong_group[i_train] != -1:
continue
if not train[i_train]:
continue
train_group[group_num_train] = set()
dfs_train(i_train, group_num_train)
group_num_train += 1
# 出力
for i in range(1, n + 1):
rg = road_belong_group[i]
tg = train_belong_group[i]
if rg == -1 or tg == -1:
print(1, end= ' ')
else:
linked_city = len(road_group[rg] & train_group[tg] )
if linked_city == 0:
linked_city += 1
print(linked_city, end = ' ')
if __name__ == '__main__':
main() |
s852900069 | p03855 | u072717685 | 1589144255 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2113 | 208500 | 2877 |
import sys
input = sys.stdin.readline
road = {}
train = {}
node_all = set()
node_seen = set()
road_belong_group = []
train_belong_group = []
road_group = {}
train_group = {}
def dfs_road(t_node, group_num):
global road_group, road_belong_group, node_seen
road_belong_group[t_node] = group_num
road_group[group_num].add(t_node)
node_seen.add(t_node)
#next_nodes = set(road[t_node]) - node_seen
next_nodes = road[t_node]
if len(next_nodes) == 0:
return
else:
for next in next_nodes:
if next not in node_seen:
dfs_road(next, group_num)
def dfs_train(t_node, group_num):
global node_seen, train_group, train_belong_group
train_belong_group[t_node] = group_num
train_group[group_num].add(t_node)
node_seen.add(t_node)
#next_nodes = set(train[t_node]) - node_seen
next_nodes = train[t_node]
if len(next_nodes) == 0:
return
else:
for next in next_nodes:
if next not in node_seen:
dfs_train(next, group_num)
def main():
global road, train, node_seen, road_group, train_group, node_all, road_belong_group,train_belong_group
# 入力
n, k, l = map(int, input().split())
node_all = set([i for i in range(1, n + 1)])
road = {e:[] for e in range(1, n + 1)}
train = {e: [] for e in range(1, n + 1)}
road_belong_group = {e: -1 for e in range(1, n + 1)}
train_belong_group = {e: -1 for e in range(1, n + 1)}
node_checked_road = 0
node_checked_train = 0
for _ in range(k):
p, q = map(int, input().split())
road[p].append(q)
road[q].append(p)
for _ in range(l):
s, t = map(int, input().split())
train[s].append(t)
train[t].append(s)
# 処理
## 道路
road_group[-1] = set()
train_group[-1] = set()
group_num_road = 1
for i_road in range(1, n + 1):
if road_belong_group[i_road] != -1:
continue
if not road[i_road]:
continue
road_group[group_num_road] = set()
dfs_road(i_road, group_num_road)
group_num_road += 1
## 鉄道
node_seen = set()
group_num_train = 1
for i_train in range(1, n + 1):
if train_belong_group[i_train] != -1:
continue
if not train[i_train]:
continue
train_group[group_num_train] = set()
dfs_train(i_train, group_num_train)
group_num_train += 1
# 出力
for i in range(1, n + 1):
rg = road_belong_group[i]
tg = train_belong_group[i]
if rg == -1 or tg == -1:
print(1, end= ' ')
else:
linked_city = len(road_group[rg] & train_group[tg] )
if linked_city == 0:
linked_city += 1
print(linked_city, end = ' ')
if __name__ == '__main__':
main()
|
s448012078 | p03855 | u072717685 | 1589143857 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2113 | 205160 | 2729 | import sys
input = sys.stdin.readline
road = {}
train = {}
node_all = set()
node_seen = set()
road_belong_group = []
train_belong_group = []
road_group = {}
train_group = {}
def dfs_road(t_node, group_num):
global road_group, road_belong_group, node_seen
road_belong_group[t_node] = group_num
road_group[group_num].add(t_node)
node_seen.add(t_node)
next_nodes = set(road[t_node]) - node_seen
if len(next_nodes) == 0:
return
else:
for next in next_nodes:
dfs_road(next, group_num)
def dfs_train(t_node, group_num):
global node_seen, train_group, train_belong_group
train_belong_group[t_node] = group_num
train_group[group_num].add(t_node)
node_seen.add(t_node)
next_nodes = set(train[t_node]) - node_seen
if len(next_nodes) == 0:
return
else:
for next in next_nodes:
dfs_train(next, group_num)
def main():
global road, train, node_seen, road_group, train_group, node_all, road_belong_group,train_belong_group
# 入力
n, k, l = map(int, input().split())
node_all = set([i for i in range(1, n + 1)])
road = {e:[] for e in range(1, n + 1)}
train = {e: [] for e in range(1, n + 1)}
road_belong_group = {e: -1 for e in range(1, n + 1)}
train_belong_group = {e: -1 for e in range(1, n + 1)}
node_checked_road = 0
node_checked_train = 0
for _ in range(k):
p, q = map(int, input().split())
road[p].append(q)
road[q].append(p)
for _ in range(l):
s, t = map(int, input().split())
train[s].append(t)
train[t].append(s)
# 処理
## 道路
road_group[-1] = set()
train_group[-1] = set()
group_num_road = 1
for i_road in range(1, n + 1):
if road_belong_group[i_road] != -1:
continue
if not road[i_road]:
continue
road_group[group_num_road] = set()
dfs_road(i_road, group_num_road)
group_num_road += 1
## 鉄道
node_seen = set()
group_num_train = 1
for i_train in range(1, n + 1):
if train_belong_group[i_train] != -1:
continue
if not train[i_train]:
continue
train_group[group_num_train] = set()
dfs_train(i_train, group_num_train)
group_num_train += 1
# 出力
for i in range(1, n + 1):
rg = road_belong_group[i]
tg = train_belong_group[i]
if rg == -1 or tg == -1:
print(1, end= ' ')
else:
linked_city = len(road_group[rg] & train_group[tg] )
if linked_city == 0:
linked_city += 1
print(linked_city, end = ' ')
if __name__ == '__main__':
main()
|
s414672834 | p03855 | u072717685 | 1589141921 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2111 | 169012 | 2872 |
import sys
input = sys.stdin.readline
large_p = 10**9 + 7
road = {}
train = {}
node_all = set()
node_seen = set()
road_belong_group = []
train_belong_group = []
road_group = {}
train_group = {}
def dfs_road(t_node, group_num):
global node_seen, road_group, road_belong_group
node_seen.add(t_node)
road_belong_group[t_node] = group_num
road_group[group_num].add(t_node)
next_nodes = set(road[t_node]) - node_seen
if not list(next_nodes):
return
else:
for next in next_nodes:
dfs_road(next, group_num)
def dfs_train(t_node, group_num):
global node_seen, train_group, train_belong_group
node_seen.add(t_node)
train_belong_group[t_node] = group_num
train_group[group_num].add(t_node)
next_nodes = set(train[t_node]) - node_seen
if not list(next_nodes):
return
else:
for next in next_nodes:
dfs_train(next, group_num)
def main():
global road, train, node_seen, road_group, train_group, node_all, road_belong_group,train_belong_group
# 入力
n, k, l = map(int, input().split())
node_all = set([i for i in range(1, n + 1)])
road = {e:[] for e in range(1, n + 1)}
road_belong_group = [0] * (n + 1)
train_belong_group = [0] * (n + 1)
road_belong_group[0] = -1
train_belong_group[0] = -1
for _ in range(k):
p, q = map(int, input().split())
road[p].append(q)
road[q].append(p)
train = {e:[] for e in range(1, n + 1)}
for _ in range(l):
s, t = map(int, input().split())
train[s].append(t)
train[t].append(s)
# 処理
## 道路
road_group[-1] = set()
train_group[-1] = set()
group_num_road = 1
while list(node_all - node_seen):
node_remain = road_belong_group.index(0)
if node_remain == 0:
node_remain = 1
if not road[node_remain]:
road_belong_group[node_remain] = -1
node_seen.add(node_remain)
continue
road_group[group_num_road] = set()
dfs_road(node_remain, group_num_road)
group_num_road += 1
## 鉄道
group_num_train = 1
node_seen = set()
while list(node_all - node_seen):
node_remain = train_belong_group.index(0)
if node_remain == 0:
node_remain = 1
if not train[node_remain]:
train_belong_group[node_remain] = -1
node_seen.add(node_remain)
continue
train_group[group_num_train] = set()
dfs_train(node_remain, group_num_train)
group_num_train += 1
# 出力
for i in range(1, n + 1):
linked_city = len(road_group[road_belong_group[i]] & train_group[train_belong_group[i]] )
if linked_city == 0:
linked_city += 1
print(linked_city, end = ' ')
if __name__ == '__main__':
main()
|
s036232867 | p03855 | u072717685 | 1589141386 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 115128 | 2852 |
import sys
input = sys.stdin.readline
road = {}
train = {}
node_all = set()
node_seen = set()
road_belong_group = []
train_belong_group = []
road_group = {}
train_group = {}
def dfs_road(t_node, group_num):
global node_seen, road_group, road_belong_group
node_seen.add(t_node)
road_belong_group[t_node] = group_num
road_group[group_num].add(t_node)
next_nodes = set(road[t_node]) - node_seen
if not list(next_nodes):
return
else:
for next in next_nodes:
dfs_road(next, group_num)
def dfs_train(t_node, group_num):
global node_seen, train_group, train_belong_group
node_seen.add(t_node)
train_belong_group[t_node] = group_num
train_group[group_num].add(t_node)
next_nodes = set(train[t_node]) - node_seen
if not list(next_nodes):
return
else:
for next in next_nodes:
dfs_train(next, group_num)
def main():
global road, train, node_seen, road_group, train_group, node_all, road_belong_group,train_belong_group
# 入力
n, k, l = map(int, input().split())
node_all = set([i for i in range(1, n + 1)])
road = {e:[] for e in range(1, n + 1)}
road_belong_group = [0] * (n + 1)
train_belong_group = [0] * (n + 1)
road_belong_group[0] = -1
train_belong_group[0] = -1
for _ in range(k):
p, q = map(int, input().split())
road[p].append(q)
road[q].append(p)
train = {e:[] for e in range(1, n + 1)}
for _ in range(l):
s, t = map(int, input().split())
train[s].append(t)
train[t].append(s)
# 処理
## 道路
road_group[-1] = set()
train_group[-1] = set()
group_num_road = 1
while list(node_all - node_seen):
node_remain = road_belong_group.index(0)
if node_remain == 0:
node_remain = 1
if not road[node_remain]:
road_belong_group[node_remain] = -1
node_seen.add(node_remain)
continue
road_group[group_num_road] = set()
dfs_road(node_remain, group_num_road)
group_num_road += 1
## 鉄道
group_num_train = 1
node_seen = set()
while list(node_all - node_seen):
node_remain = train_belong_group.index(0)
if node_remain == 0:
node_remain = 1
if not train[node_remain]:
train_belong_group[node_remain] = -1
node_seen.add(node_remain)
continue
train_group[group_num_train] = set()
dfs_train(node_remain, group_num_train)
group_num_train += 1
# 出力
for i in range(1, n + 1):
linked_city = len(road_group[road_belong_group[i]] & train_group[train_belong_group[i]] )
if linked_city == 0:
linked_city += 1
print(linked_city, end = ' ')
if __name__ == '__main__':
main()
|
s714685253 | p03855 | u197457087 | 1588638648 | Python | Python (3.4.3) | py | Runtime Error | 53 | 14288 | 1728 | class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
"""
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 と y のグループを結合
"""
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
"""
x と y が同じグループか否か
"""
return self.find(x) == self.find(y)
def get_size(self, x):
"""
x が属するグループの要素数
"""
x = self.find(x)
return self.size[x]
from collections import defaultdict
N, K, L = map(int, input().split())
# 道路のUnionFind
uf1 = UnionFind(N)
for i in range(K):
p, q = map(int, input().split())
uf1.union(p - 1, q - 1)
# 鉄道のUnionFind
uf2 = UnionFind(N)
for i in range(L):
r, s = map(int, input().split())
uf2.union(r - 1, s - 1)
# 道路と鉄道の連結の組み合わせ（根のペアのカウント）
c = {}
for i in range(N):
if (uf1.find(i), uf2.find(i)) in c:
c[(uf1.find(i), uf2.find(i))] += 1
else:
c[(uf1.find(i), uf2.find(i))] = 1
# 回答を出力
for i in range(N):
print(c[(uf1.find(i), uf2.find(i))]) |
s506473072 | p03855 | u892487306 | 1588344806 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 2006 | import sys
sys.setrecursionlimit(10**12)
class UnionFind:
def __init__(self, n):
self.n = n
# access m-th node by index `m`, not `m - 1`
self.roots = [i for i in range(n + 1)]
self.ranks = [0 for _ in range(n + 1)]
self.group_sizes = [1 for _ in range(n + 1)]
def find_root(self, node):
root_node = self.roots[node]
if node == root_node:
return root_node
else:
new_root_node = self.find_root(root_node)
self.roots[node] = new_root_node # reduction
return root_node
def union(self, one, other):
one_root = self.find_root(one)
other_root = self.find_root(other)
if one_root == other_root:
return
if self.ranks[one_root] < self.ranks[other_root]:
self.roots[one_root] = other_root
self.group_sizes[other_root] += self.group_sizes[one_root]
else:
self.roots[other_root] = one_root
self.group_sizes[one_root] += self.group_sizes[other_root]
if self.ranks[one_root] == self.ranks[other_root]:
self.ranks[other_root] += 1
def is_same_group(self, one, other):
one_root = self.find_root(one)
other_root = self.find_root(other)
return one_root == other_root
def group_size(self, node):
root_node = self.find_root(node)
return self.group_sizes[root_node]
def main():
N, K, L = list(map(int, input().split(' ')))
road_tree = UnionFind(N)
for _ in range(K):
p, q = list(map(int, input().split(' ')))
road_tree.union(p, q)
road_train_tree = UnionFind(N)
for _ in range(L):
r, s = list(map(int, input().split(' ')))
if not road_tree.is_same_group(r, s):
continue
road_train_tree.union(r, s)
answer = ' '.join([str(road_train_tree.group_size(node)) for node in range(1, N + 1)])
print(answer)
if __name__ == '__main__':
main() |
s601112638 | p03855 | u892487306 | 1588344691 | Python | Python (3.4.3) | py | Runtime Error | 1426 | 675504 | 2006 | import sys
sys.setrecursionlimit(10**7)
class UnionFind:
def __init__(self, n):
self.n = n
# access m-th node by index `m`, not `m - 1`
self.roots = [i for i in range(n + 1)]
self.ranks = [0 for _ in range(n + 1)]
self.group_sizes = [1 for _ in range(n + 1)]
def find_root(self, node):
root_node = self.roots[node]
if node == root_node:
return root_node
else:
new_root_node = self.find_root(root_node)
self.roots[node] = new_root_node # reduction
return root_node
def union(self, one, other):
one_root = self.find_root(one)
other_root = self.find_root(other)
if one_root == other_root:
return
if self.ranks[one_root] < self.ranks[other_root]:
self.roots[one_root] = other_root
self.group_sizes[other_root] += self.group_sizes[one_root]
else:
self.roots[other_root] = one_root
self.group_sizes[one_root] += self.group_sizes[other_root]
if self.ranks[one_root] == self.ranks[other_root]:
self.ranks[other_root] += 1
def is_same_group(self, one, other):
one_root = self.find_root(one)
other_root = self.find_root(other)
return one_root == other_root
def group_size(self, node):
root_node = self.find_root(node)
return self.group_sizes[root_node]
def main():
N, K, L = list(map(int, input().split(' ')))
road_tree = UnionFind(N)
for _ in range(K):
p, q = list(map(int, input().split(' ')))
road_tree.union(p, q)
road_train_tree = UnionFind(N)
for _ in range(L):
r, s = list(map(int, input().split(' ')))
if not road_tree.is_same_group(r, s):
continue
road_train_tree.union(r, s)
answer = ' '.join([str(road_train_tree.group_size(node)) for node in range(1, N + 1)])
print(answer)
if __name__ == '__main__':
main()
|
s506111631 | p03855 | u892487306 | 1588343888 | Python | Python (3.4.3) | py | Runtime Error | 204 | 14928 | 1964 | class UnionFind:
def __init__(self, n):
self.n = n
# access m-th node by index `m`, not `m - 1`
self.roots = [i for i in range(n + 1)]
self.ranks = [0 for _ in range(n + 1)]
self.group_sizes = [1 for _ in range(n + 1)]
def find_root(self, node):
root_node = self.roots[node]
if node == root_node:
return root_node
else:
new_root_node = self.find_root(root_node)
self.roots[node] = new_root_node # reduction
return root_node
def union(self, one, other):
one_root = self.find_root(one)
other_root = self.find_root(other)
if one_root == other_root:
return
if self.ranks[one_root] < self.ranks[other_root]:
self.roots[one_root] = other_root
self.group_sizes[other_root] += self.group_sizes[one_root]
else:
self.roots[other_root] = one_root
self.group_sizes[one_root] += self.group_sizes[other_root]
if self.ranks[one_root] == self.ranks[other_root]:
self.ranks[other_root] += 1
def is_same_group(self, one, other):
one_root = self.find_root(one)
other_root = self.find_root(other)
return one_root == other_root
def group_size(self, node):
root_node = self.find_root(node)
return self.group_sizes[root_node]
def main():
N, K, L = list(map(int, input().split(' ')))
road_tree = UnionFind(N)
for _ in range(K):
p, q = list(map(int, input().split(' ')))
road_tree.union(p, q)
road_train_tree = UnionFind(N)
for _ in range(L):
r, s = list(map(int, input().split(' ')))
if not road_tree.is_same_group(r, s):
continue
road_train_tree.union(r, s)
answer = ' '.join([str(road_train_tree.group_size(node)) for node in range(1, N + 1)])
print(answer)
if __name__ == '__main__':
main()
|
s608324154 | p03855 | u346812984 | 1588031293 | Python | Python (3.4.3) | py | Runtime Error | 2104 | 13964 | 1778 | import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
class UnionFind:
def __init__(self, n_nodes):
self.n_nodes = n_nodes
self.parents = [-1] * n_nodes
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def get_size(self, x):
return -self.parents[self.find(x)]
def check(self, x, y):
return self.find(x) == self.find(y)
def get_parent_list(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def get_members(self, x):
parent = self.find(x)
return [i for i in range(self.n_nodes) if self.find(i) == parent]
def get_members_dict(self):
return {par: self.get_members(par) for par in self.get_parent_list()}
def main():
N, K, L = map(int, input().split())
tree_road = UnionFind(N)
tree_subway = UnionFind(N)
for _ in range(K):
p, q = map(int, input().split())
p -= 1
q -= 1
tree_road.unite(p, q)
for _ in range(L):
r, s = map(int, input().split())
r -= 1
s -= 1
tree_subway.unite(r, s)
d1 = tree_road.get_members_dict()
d2 = tree_subway.get_members_dict()
for i in range(N):
m1 = set(d1[i])
m2 = set(d2[i])
print(len(m1 & m2), end=" ")
if __name__ == "__main__":
main()
|
s362561657 | p03855 | u292978925 | 1586538506 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1112 | """
in1 = '7 4 4'
in2 = ['1 2', '2 3', '2 5', '6 7', '3 5', '4 5', '3 4', '6 7']
N, K, L = map(int, in1.split())
pqrs = []
for idx1 in range(K + L):
temp0, temp1 = map(int, in2[idx1].split())
pqrs.append([temp0, temp1])
"""
N, K, L = map(int, input().split())
pqrs = []
for idx1 in range(K + L):
temp0, temp1 = map(int, input().sprit())
pqrs.append([temp0, temp1])
def makeTree(a):
aT = list(range(N + 1))
for p, q in a:
rootp = getRoot(aT, p)
rootq = getRoot(aT, q)
thisRoot = max(rootp, rootq, q)
aT[p] = thisRoot
aT[q] = thisRoot
aT[rootp] = thisRoot
aT[rootq] = thisRoot
return aT
def getRoot(a,i):
if a[i] == i:
return i
else:
a[i] = getRoot(a, a[i])
return a[i]
MTree = makeTree(pqrs[0:K])
TTree = makeTree(pqrs[K:])
aRet = []
dRet = {}
for idx1 in range(1, N + 1):
Comb = (getRoot(MTree, idx1), getRoot(TTree, idx1))
aRet.append(Comb)
if Comb in dRet:
dRet[Comb] += 1
else:
dRet[Comb] = 1
print(" ".join([str(dRet[_]) for _ in aRet]))
|
s339768878 | p03855 | u292978925 | 1586537973 | Python | Python (3.4.3) | py | Runtime Error | 20 | 4596 | 1068 | """
in1 = '7 4 4'
in2 = ['1 2', '2 3', '2 5', '6 7', '3 5', '4 5', '3 4', '6 7']
N, K, L = [int(_) for _ in in1.split()]
pqrs = [[int(_) for _ in _.split()] for _ in in2]
"""
N, K, L = map(int, input().split())
pqrs = [[0] * 2] * N
for idx1 in range(N):
temp = input().sprit()
pqrs[idx1][0] = temp[0]
pqrs[idx1][1] = temp[1]
def makeTree(a):
aT = list(range(N + 1))
for p, q in a:
rootp = getRoot(aT, p)
rootq = getRoot(aT, q)
thisRoot = max(rootp, rootq, q)
aT[p] = thisRoot
aT[q] = thisRoot
aT[rootp] = thisRoot
aT[rootq] = thisRoot
return aT
def getRoot(a,i):
if a[i] == i:
return i
else:
a[i] = getRoot(a, a[i])
return a[i]
MTree = makeTree(pqrs[0:K])
TTree = makeTree(pqrs[K:])
aRet = []
dRet = {}
for idx1 in range(1, N + 1):
Comb = (getRoot(MTree, idx1), getRoot(TTree, idx1))
aRet.append(Comb)
if Comb in dRet:
dRet[Comb] += 1
else:
dRet[Comb] = 1
print(" ".join([str(dRet[_]) for _ in aRet]))
|
s287484340 | p03855 | u292978925 | 1586537636 | Python | Python (3.4.3) | py | Runtime Error | 26 | 10740 | 1024 | """
in1 = '7 4 4'
in2 = ['1 2', '2 3', '2 5', '6 7', '3 5', '4 5', '3 4', '6 7']
N, K, L = [int(_) for _ in in1.split()]
pqrs = [[int(_) for _ in _.split()] for _ in in2]
"""
N, K, L = [int(idx1) for idx1 in input().split()]
pqrs = [[int(idx1) for idx1 in item1.split()] for item1 in input()]
def makeTree(a):
aT = list(range(N + 1))
for p, q in a:
rootp = getRoot(aT, p)
rootq = getRoot(aT, q)
thisRoot = max(rootp, rootq, q)
aT[p] = thisRoot
aT[q] = thisRoot
aT[rootp] = thisRoot
aT[rootq] = thisRoot
return aT
def getRoot(a,i):
if a[i] == i:
return i
else:
a[i] = getRoot(a, a[i])
return a[i]
MTree = makeTree(pqrs[0:K])
TTree = makeTree(pqrs[K:])
aRet = []
dRet = {}
for idx1 in range(1, N + 1):
Comb = (getRoot(MTree, idx1), getRoot(TTree, idx1))
aRet.append(Comb)
if Comb in dRet:
dRet[Comb] += 1
else:
dRet[Comb] = 1
print(" ".join([str(dRet[_]) for _ in aRet]))
|
s877643109 | p03855 | u292978925 | 1586537566 | Python | Python (3.4.3) | py | Runtime Error | 25 | 10864 | 1004 | """
in1 = '7 4 4'
in2 = ['1 2', '2 3', '2 5', '6 7', '3 5', '4 5', '3 4', '6 7']
N, K, L = [int(_) for _ in in1.split()]
pqrs = [[int(_) for _ in _.split()] for _ in in2]
"""
N, K, L = [int(_) for _ in input().split()]
pqrs = [[int(_) for _ in _.split()] for _ in input()]
def makeTree(a):
aT = list(range(N + 1))
for p, q in a:
rootp = getRoot(aT, p)
rootq = getRoot(aT, q)
thisRoot = max(rootp, rootq, q)
aT[p] = thisRoot
aT[q] = thisRoot
aT[rootp] = thisRoot
aT[rootq] = thisRoot
return aT
def getRoot(a,i):
if a[i] == i:
return i
else:
a[i] = getRoot(a, a[i])
return a[i]
MTree = makeTree(pqrs[0:K])
TTree = makeTree(pqrs[K:])
aRet = []
dRet = {}
for idx1 in range(1, N + 1):
Comb = (getRoot(MTree, idx1), getRoot(TTree, idx1))
aRet.append(Comb)
if Comb in dRet:
dRet[Comb] += 1
else:
dRet[Comb] = 1
print(" ".join([str(dRet[_]) for _ in aRet]))
|
s327740183 | p03855 | u353797797 | 1586180517 | Python | Python (3.4.3) | py | Runtime Error | 2517 | 8800 | 1618 | import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class UnionFind:
def __init__(self, n):
self.state = [-1] * n
self.size_table = [1<<i for i in range(n)]
# cntはグループ数
# self.cnt = n
def root(self, u):
v = self.state[u]
if v < 0: return u
self.state[u] = res = self.root(v)
return res
def merge(self, u, v):
ru = self.root(u)
rv = self.root(v)
if ru == rv: return
du = self.state[ru]
dv = self.state[rv]
if du > dv: ru, rv = rv, ru
if du == dv: self.state[ru] -= 1
self.state[rv] = ru
# self.cnt -= 1
self.size_table[ru] |= self.size_table[rv]
self.size_table[rv]=0
return
# グループの要素数
def size(self, u):
return self.size_table[self.root(u)]
def popcnt(a):
res=0
while a:
res+=a&1
a>>=1
return res
def main():
n,k,l=MI()
road=UnionFind(n)
train=UnionFind(n)
for _ in range(k):
u,v=MI1()
road.merge(u,v)
for _ in range(l):
u,v=MI1()
train.merge(u,v)
ans=[popcnt(road.size(i)&train.size(i)) for i in range(n)]
print(*ans)
main()
|
s625352776 | p03855 | u353797797 | 1586180082 | Python | Python (3.4.3) | py | Runtime Error | 2722 | 8672 | 1541 | import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class UnionFind:
def __init__(self, n):
self.state = [-1] * n
self.size_table = [1<<i for i in range(n)]
# cntはグループ数
# self.cnt = n
def root(self, u):
v = self.state[u]
if v < 0: return u
self.state[u] = res = self.root(v)
return res
def merge(self, u, v):
ru = self.root(u)
rv = self.root(v)
if ru == rv: return
du = self.state[ru]
dv = self.state[rv]
if du > dv: ru, rv = rv, ru
if du == dv: self.state[ru] -= 1
self.state[rv] = ru
# self.cnt -= 1
self.size_table[ru] |= self.size_table[rv]
self.size_table[rv]=0
return
# グループの要素数
def size(self, u):
return self.size_table[self.root(u)]
def main():
n,k,l=MI()
road=UnionFind(n)
train=UnionFind(n)
for _ in range(k):
u,v=MI1()
road.merge(u,v)
for _ in range(l):
u,v=MI1()
train.merge(u,v)
ans=[bin(road.size(i)&train.size(i)).count("1") for i in range(n)]
print(*ans)
main()
|
s420798245 | p03855 | u353797797 | 1586179506 | Python | Python (3.4.3) | py | Runtime Error | 2348 | 9440 | 1510 | import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class UnionFind:
def __init__(self, n):
self.state = [-1] * n
self.size_table = [1<<i for i in range(n)]
# cntはグループ数
# self.cnt = n
def root(self, u):
v = self.state[u]
if v < 0: return u
self.state[u] = res = self.root(v)
return res
def merge(self, u, v):
ru = self.root(u)
rv = self.root(v)
if ru == rv: return
du = self.state[ru]
dv = self.state[rv]
if du > dv: ru, rv = rv, ru
if du == dv: self.state[ru] -= 1
self.state[rv] = ru
# self.cnt -= 1
self.size_table[ru] |= self.size_table[rv]
return
# グループの要素数
def size(self, u):
return self.size_table[self.root(u)]
def main():
n,k,l=MI()
road=UnionFind(n)
train=UnionFind(n)
for _ in range(k):
u,v=MI1()
road.merge(u,v)
for _ in range(l):
u,v=MI1()
train.merge(u,v)
ans=[bin(road.size(i)&train.size(i)).count("1") for i in range(n)]
print(*ans)
main() |
s776697203 | p03855 | u691018832 | 1585543175 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 1603 | import sys
from collections import defaultdict
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n, k, l = map(int, input().split())
uf_k = UnionFind(n)
uf_l = UnionFind(n)
for i in range(k):
p, q = map(int, input().split())
uf_k.union(p - 1, q - 1)
for i in range(l):
r, s = map(int, input().split())
uf_l.union(r - 1, s - 1)
d = defaultdict(int)
for i in range(n):
d[uf_k.find(i), uf_l.find(i)] += 1
print(*d[uf_k.find(i), uf_l.find(i)] for i in range(n))
|
s963283972 | p03855 | u361381049 | 1583364815 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1051 | from sys import setrecursionlimit
setrecursionlimit(10 ** 9)
class UnionFind():
def __init__(self, n):
self.n = n
self.d = [-1] * n
def find(self, x):
if self.d[x] < 0:
return x
else:
self.d[x] = self.find(self.d[x])
return self.d[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
else:
if self.d[x] > self.d[y]:
x, y = y, x
self.d[x] += self.d[y]
self.d[y] = x
return True
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.d[self.find(x)]
n, k, l = map(int, input().split())
uf = UnionFind(n)
for i in range(k):
p, q = map(int, input().split())
p -= 1
q -= 1
uf.unite(p, q)
ans = [1] * n
for i in range(l):
r, s = map(int, input().split())
r -= 1
s -= 1
if uf.same(r, s) == True:
# print(uf.d)
print(' '.join(map(str, ans))) |
s827133956 | p03855 | u185325486 | 1582741919 | Python | Python (3.4.3) | py | Runtime Error | 17 | 3064 | 621 | H, W = map(int, input().split())
A = [[int(i) for i in input().split()] for _ in range(H)]
dp = [[0]*W for _ in range(H)]
memo = [[-1]*W for _ in range(H)]
mod = 10**9+7
result = 0
def aaa(x,y):
move_list = [[x+1,y], [x-1, y], [x,y+1],[x,y-1]]
val = A[x][y]
cnt = 1
for new_x, new_y in move_list:
if 0 <= new_x <H and 0<=new_y<W and A[new_x][new_y] > val:
cnt += aaa(new_x,new_y) if memo[new_x][new_y] == -1 else memo[new_x][new_y]
cnt %= mod
memo[x][y] = cnt
return cnt
for i in range(H):
for j in range(W):
result += aaa(i,j)
print(result) |
s831159996 | p03855 | u541610817 | 1581652122 | Python | Python (3.4.3) | py | Runtime Error | 2114 | 194204 | 859 | N, K, L = [int(x) for x in input().split()]
dict = {}
for i in range(1, N + 1):
dict[i] = [set(), set()]
dict[i][0].add(i)
dict[i][1].add(i)
for i in range(K):
p, q = [int(x) for x in input().split()]
dict[p][0].add(q)
dict[q][0].add(p)
for i in range(L):
r, s = [int(x) for x in input().split()]
dict[r][1].add(s)
dict[s][1].add(r)
def my_dfs(city, opt, s):
if dict[city][opt] <= s:
return s
for i in dict[city][opt]:
if i in s:
continue
if i == city:
s.add(i)
continue
s.add(i)
s.update(my_dfs(i, opt, s))
return s
for i in range(1, N + 1):
dict[i][0].update(my_dfs(i, 0, set()))
dict[i][1].update(my_dfs(i, 1, set()))
ans_lst = []
for i in range(1, N + 1):
ans_lst.append(len(dict[i][0] & dict[i][1]))
print(*ans_lst)
|
s548384246 | p03855 | u541610817 | 1581583257 | Python | Python (3.4.3) | py | Runtime Error | 2114 | 198300 | 858 | N, K, L = [int(x) for x in input().split()]
dict = {}
for i in range(1, N + 1):
dict[i] = [set(), set()]
dict[i][0].add(i)
dict[i][1].add(i)
for i in range(K):
p, q = [int(x) for x in input().split()]
dict[p][0].add(q)
dict[q][0].add(p)
for i in range(L):
r, s = [int(x) for x in input().split()]
dict[r][1].add(s)
dict[s][1].add(r)
def my_dfs(city, opt, s):
if dict[city][opt] <= s:
return s
for i in dict[city][opt]:
if i in s:
continue
if i == city:
s.add(i)
continue
s.add(i)
s.update(my_dfs(i, opt, s))
return s
for i in range(1, N + 1):
dict[i][0].update(my_dfs(i, 0, set()))
dict[i][1].update(my_dfs(i, 1, set()))
ans_lst = []
for i in range(1, N + 1):
ans_lst.append(len(dict[i][0] & dict[i][1]))
print(ans_lst)
|
s107629033 | p03855 | u116348130 | 1581184485 | Python | Python (3.4.3) | py | Runtime Error | 346 | 52016 | 1719 | import sys
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
find = self.find(x)
return [i for i in range(self.n) if self.find(i) == find]
def finds(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.finds())
def all_group_members(self):
return {r: self.members(r) for r in self.finds()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.finds())
input = sys.stdin.readline
n, k, l = map(int, input().split())
w = [list(map(int, input().split())) for i in range(k+l)]
ro = w[:k]
ra = w[l:]
answer = ""
d = defaultdict(int)
ro_cl = UnionFind(n)
ra_cl = UnionFind(n)
for p, q in ro:
ro_cl.union(p-1, q-1)
for p, q in ra:
ra_cl.union(p-1, q-1)
for i in range(n):
print(ro_cl.members(i))
print(ra_cl.members(i))
if i != 0:
answer += " "
answer += str(len([n for n in ro_cl.members(i) if n in ra_cl.members(i)]))
# d[(ro_cl.find(i), ra_cl.find(i))] += 1
print(answer)
|
s834141183 | p03855 | u386170566 | 1580082232 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 1377 | #uniontree
#D - 連結 / Connectivity
#https://atcoder.jp/contests/abc049/tasks/arc065_b
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
p = UnionFind(n)
r = UnionFind(n)
ans = []
n, k, l = list(map(int,input().split()))
for _ in range(k):
a,b = list(map(int,input().split()))
p.union(a-1,b-1)
for _ in range(l):
c, d = list(map(int,input().split()))
r.union(c-1,d-1)
for i in range(n):
s = p.members(i)
t = r.members(i)
#print(s,t)
count = 0
for i in s:
if i in t:
count += 1
ans.append(count)
#print(''.join(ans))、なぜか通らない、おそらくstrに変更しないと不可の模様
print(' '.join(map(str, ans))) |
s568468010 | p03855 | u386170566 | 1580082135 | Python | PyPy3 (2.4.0) | py | Runtime Error | 180 | 38740 | 1377 | #uniontree
#D - 連結 / Connectivity
#https://atcoder.jp/contests/abc049/tasks/arc065_b
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
p = UnionFind(n)
r = UnionFind(n)
ans = []
n, k, l = list(map(int,input().split()))
for _ in range(k):
a,b = list(map(int,input().split()))
p.union(a-1,b-1)
for _ in range(l):
c, d = list(map(int,input().split()))
r.union(c-1,d-1)
for i in range(n):
s = p.members(i)
t = r.members(i)
#print(s,t)
count = 0
for i in s:
if i in t:
count += 1
ans.append(count)
#print(''.join(ans))、なぜか通らない、おそらくstrに変更しないと不可の模様
print(' '.join(map(str, ans))) |
s877901172 | p03855 | u359619351 | 1579139725 | Python | PyPy3 (2.4.0) | py | Runtime Error | 207 | 44012 | 2265 | import sys
sys.setrecursionlimit(4100000)
import math
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
from unionfind import UnionFind, UnionFindCounter
def resolve():
# S = [x for x in sys.stdin.readline().split()][0] # 文字列 一つ
# N = [int(x) for x in sys.stdin.readline().split()][0] # int 一つ
N, K, L = [int(x) for x in sys.stdin.readline().split()] # 複数int
# grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)] # 文字列grid
grid = [[int(x) - 1 for x in sys.stdin.readline().split()]
for _ in range(K + L)] # int grid
logger.debug('{}'.format([]))
p_uf = UnionFind(N)
r_uf = UnionFind(N)
both_uf = UnionFindCounter(N)
for k in range(K):
p, q = grid[k]
p_uf.unite(p, q)
for l in range(K, K + L):
r, s = grid[l]
r_uf.unite(r, s)
if p_uf.isSame(r, s):
both_uf.unite(r, s)
print(' '.join([str(x) for x in both_uf.getCount()]))
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4 3 1
1 2
2 3
3 4
2 3"""
output = """1 2 2 1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """4 2 2
1 2
2 3
1 4
2 3"""
output = """1 2 2 1"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """7 4 4
1 2
2 3
2 5
6 7
3 5
4 5
3 4
6 7"""
output = """1 1 2 1 2 2 2"""
self.assertIO(input, output)
def test_入力例_4(self):
input = """2 1 1
1 2
1 2"""
output = """2 2"""
self.assertIO(input, output)
|
s170312757 | p03855 | u100418016 | 1578293177 | Python | Python (3.4.3) | py | Runtime Error | 2109 | 141008 | 863 | import numpy as np
a,b,c= input().split(" ")
arr_x = np.repeat(0, int(a)**2).reshape(int(a), int(a))
arr_y = np.repeat(0, int(a)**2).reshape(int(a), int(a))
for i in range(int(b)):
inb = input().split(" ")
arr_x[int(inb[0])-1][int(inb[1])-1] = 1
arr_x[int(inb[1])-1][int(inb[0])-1] = 1
for i in range(int(c)):
inb = input().split(" ")
arr_y[int(inb[0])-1][int(inb[1])-1] = 1
arr_y[int(inb[1])-1][int(inb[0])-1] = 1
for i in range(int(a)):
arr_x[i][i]=1
for n in range(int(a)-1):
if(arr_x[i][n]==1):
arr_x[i]= arr_x[i] + arr_x[n]
for i in range(int(a)):
arr_y[i][i]=1
for n in range(int(a)):
if(arr_y[i][n]==1):
arr_y[i]= arr_y[i] + arr_y[n]
arr_x = -(arr_x * -1 //2**10)
arr_y = -(arr_y * -1 //2**10)
asd = arr_x + arr_y
asd = asd//2
ans = asd.sum(axis=0)
for i in range(int(a)):
print(ans[i], end="") |
s362592322 | p03855 | u386170566 | 1578079788 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3064 | 1366 | #D - 連結 / Connectivity
#https://atcoder.jp/contests/abc049/tasks/arc065_b
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
p = UnionFind(n)
r = UnionFind(n)
ans = []
n, k, l = list(map(int,input().split()))
for _ in range(k):
a,b = list(map(int,input().split()))
p.union(a-1,b-1)
for _ in range(l):
c, d = list(map(int,input().split()))
r.union(c-1,d-1)
for i in range(n):
s = p.members(i)
t = r.members(i)
#print(s,t)
count = 0
for i in s:
if i in t:
count += 1
ans.append(count)
#print(''.join(ans))、なぜか通らない、おそらくstrに変更しないと不可の模様
print(' '.join(map(str, ans))) |
s552411485 | p03855 | u724687935 | 1577441694 | Python | PyPy3 (2.4.0) | py | Runtime Error | 206 | 39408 | 483 | N, K, L = map(int, input().split())
uf = UnionFind(2 * N)
for _ in range(K):
p, q = map(int, input().split())
uf.union(p - 1, q - 1)
for _ in range(L):
r, s = map(int, input().split())
uf.union(r - 1 + N, s - 1 + N)
ans = [0] * N
for i in range(N):
cnt = 0
for j in range(N):
if uf.find(i) == uf.find(j) and uf.find(i + N) == uf.find(j + N):
cnt += 1
ans[i] = cnt
for i in range(N - 1):
print(ans[i], end=' ')
print(ans[N - 1])
|
s120050385 | p03855 | u875600867 | 1576468048 | Python | Python (3.4.3) | py | Runtime Error | 457 | 7396 | 1836 | # union-find木
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
##
# N個の都市
# K本の道路
# L本の鉄道
N, K, L = map(int, input().split())
# N都市を初期の要素数とする
# 道路と鉄道をそれぞれ別のunion-find木として表現する
uf_p = UnionFind(N)
uf_t = UnionFind(N)
# 道路の木
for _ in range(K):
x,y = map(int, input().split())
uf_p.union(x-1,y-1)
# 鉄道の木
for _ in range(L):
x,y = map(int, input().split())
uf_.tunion(x-1,y-1)
# 出力結果を整形
result = []
for i in range(N):
# 道路と鉄道の両方繋がっている件数をand条件で抽出する
result.append(str(len(set(uf_p.members(i)) & set(uf_t.members(i)))))
print(" ".join(result))
|
s664976401 | p03855 | u875600867 | 1576467987 | Python | Python (3.4.3) | py | Runtime Error | 24 | 6260 | 1840 | # union-find木
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
##
# N個の都市
# K本の道路
# L本の鉄道
N, K, L = map(int, input().split())
# N都市を初期の要素数とする
# 道路と鉄道をそれぞれ別のunion-find木として表現する
uf_p = UnionFind(N)
uf_t = UnionFind(N)
# 道路の木
for _ in range(K):
x,y = map(int, input().split())
uf_p.union(px-1,py-1)
# 鉄道の木
for _ in range(L):
x,y = map(int, input().split())
uf_.tunion(px-1,py-1)
# 出力結果を整形
result = []
for i in range(N):
# 道路と鉄道の両方繋がっている件数をand条件で抽出する
result.append(str(len(set(uf_p.members(i)) & set(uf_t.members(i)))))
print(" ".join(result))
|
s606597988 | p03855 | u875600867 | 1576467846 | Python | Python (3.4.3) | py | Runtime Error | 23 | 6260 | 1899 | # union-find木
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
##
# N個の都市
# K本の道路
# L本の鉄道
N, K, L = map(int, input().split())
# N都市を初期の要素数とする
# 道路と鉄道をそれぞれ別のunion-find木として表現する
uf_p = UnionFind(N)
uf_t = UnionFind(N)
# 道路の木
for _ in range(K):
x,y = map(int, input().split())
uf_p.union(px-1,py-1)
# 鉄道の木
for _ in range(L):
x,y = map(int, input().split())
uf_.tunion(px-1,py-1)
# 鉄道の木
for rx,ry in r:
uf_t.union(rx-1,ry-1)
# 出力結果を整形
result = []
for i in range(N):
# 道路と鉄道の両方繋がっている件数をand条件で抽出する
result.append(str(len(set(uf_p.members(i)) & set(uf_t.members(i)))))
print(" ".join(result))
|
s123526223 | p03855 | u614875193 | 1574142534 | Python | Python (3.4.3) | py | Runtime Error | 1627 | 91656 | 1107 | N,K,L=map(int,input().split())
PQ=[list(map(int,input().split())) for i in range(K)]
RS=[list(map(int,input().split())) for i in range(L)]
def find_root(root,x):
y = root[x]
if x == y:
return x
z = find_root(root,y)
root[x] = z
return z
def merge(root,size,x,y):
x = find_root(root,x)
y = find_root(root,y)
if x == y:
return
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
size[x] += sy
def UF_make(graph,n):
Root=list(range(n+1))
Size=[1] * (n+1)
for i in range(len(graph)):
merge(Root,Size,graph[i][0],graph[i][1])
for i in range(n+1):
Root[i] = find_root(Root,i)
Root.pop(0) #
return Root
PQN=UF_make(PQ,N)
RSN=UF_make(RS,N)
PQRS=[[PQN[i]*10**6+RSN[i],i,0] for i in range(N)]
PQRS.sort()
p=0
while p<N:
i=1
c=0
if p+i>=N-1:
break
while PQRS[p][0]==PQRS[p+i][0]:
c+=1
i+=1
for j in range(p,p+i):
PQRS[j][2]=c
p+=i
PQRS.sort(key=lambda x:x[1])
for i in range(N):
print(PQRS[i][2]+1,end=' ') |
s489087108 | p03855 | u190086340 | 1574025713 | Python | PyPy3 (2.4.0) | py | Runtime Error | 1490 | 138396 | 1675 | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
# root検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
def solve():
N, K, L = tuple(map(int, input().split()))
PQ = []
for _ in range(K):
PQ.append(tuple(map(int, input().split())))
RS = []
for _ in range(L):
RS.append(tuple(map(int, input().split())))
# print(N, K, L)
# print(PQ)
# print(RS)
road = UnionFind((K + 1) * 2)
rail = UnionFind((L + 1) * 2)
for a, b in PQ:
road.union(a, b)
for a, b in RS:
rail.union(a, b)
d = {}
for i in range(N):
i += 1
road_root = road.find(i)
rail_root = rail.find(i)
if not (road_root, rail_root) in d:
d[(road_root, rail_root)] = 1
else:
d[(road_root, rail_root)] += 1
ans = []
for i in range(N):
i += 1
road_root = road.find(i)
rail_root = rail.find(i)
ans.append(d[(road_root, rail_root)])
return " ".join(tuple(map(str, ans)))
if __name__ == '__main__':
res = solve()
print(res)
|
s393660490 | p03855 | u557494880 | 1573800124 | Python | Python (3.4.3) | py | Runtime Error | 18 | 3188 | 1380 | UnionFind木
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r,self.members(r)) for r in self.roots())
N,K,L = map(int,input().split())
uf = UnionFind(N)
ans = 0
for i in range(K):
p,q = map(int,input().split())
uf.union(p,q)
for i in range(L):
r,s = map(int,input().split())
if uf.same(r,s):
ans += 1 |
s756563977 | p03855 | u408620326 | 1573693429 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2108 | 114252 | 1282 | import sys
class UnionFind():
def __init__(self, N):
self.N = N
self.par = [n for n in range(N)]
self.rank = [0 for _ in range(N)]
def find(self, x):
if self.par[x] == x:
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.par[x]
y = self.par[y]
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def isSame(self, x, y):
return self.par[x] == self.par[y]
def refresh(self):
for p in range(N):
self.find(p)
N, K, L = [int(x) for x in input().strip().split()]
road = UnionFind(N)
train = UnionFind(N)
for ｋ in range(K):
p, q = [int(x) - 1 for x in input().strip().split()]
road.union(p, q)
for l in range(L):
r, s = [int(x) - 1 for x in input().strip().split()]
train.union(r, s)
road.refresh()
train.refresh()
ans = [1] * N
for i in range(N - 1):
for j in range(i + 1, N):
if i == j:
continue
if road.par[i] == road.par[j] and train.par[i] == train.par[j]:
ans[i] += 1
ans[j] += 1
print(*ans) |
s843711102 | p03855 | u408620326 | 1573692329 | Python | PyPy3 (2.4.0) | py | Runtime Error | 2108 | 112716 | 1266 | import sys
class UnionFind():
def __init__(self, N):
self.N = N
self.par = [n for n in range(N)]
self.rank = [0 for _ in range(N)]
def find(self, x):
if self.par[x] == x:
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.par[x]
y = self.par[y]
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def isSame(self, x, y):
return self.par[x] == self.par[y]
def refresh(self):
for p in range(N):
self.find(p)
N, K, L = [int(x) for x in input().strip().split()]
road = UnionFind(N)
train = UnionFind(N)
for ｋ in range(K):
p, q = [int(x) - 1 for x in input().strip().split()]
road.union(p, q)
for l in range(L):
r, s = [int(x) - 1 for x in input().strip().split()]
train.union(r, s)
road.refresh()
train.refresh()
ans = [0] * N
for i in range(N):
c = 1
for j in range(N):
if i == j:
continue
if road.par[i] == road.par[j] and train.par[i] == train.par[j]:
c += 1
ans[i] = c
print(*ans) |
s081774389 | p03855 | u408620326 | 1573692155 | Python | Python (3.4.3) | py | Runtime Error | 2105 | 22960 | 1266 | import sys
class UnionFind():
def __init__(self, N):
self.N = N
self.par = [n for n in range(N)]
self.rank = [0 for _ in range(N)]
def find(self, x):
if self.par[x] == x:
return x
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.par[x]
y = self.par[y]
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def isSame(self, x, y):
return self.par[x] == self.par[y]
def refresh(self):
for p in range(N):
self.find(p)
N, K, L = [int(x) for x in input().strip().split()]
road = UnionFind(N)
train = UnionFind(N)
for ｋ in range(K):
p, q = [int(x) - 1 for x in input().strip().split()]
road.union(p, q)
for l in range(L):
r, s = [int(x) - 1 for x in input().strip().split()]
train.union(r, s)
road.refresh()
train.refresh()
ans = [0] * N
for i in range(N):
c = 1
for j in range(N):
if i == j:
continue
if road.par[i] == road.par[j] and train.par[i] == train.par[j]:
c += 1
ans[i] = c
print(*ans) |
s487067468 | p03855 | u099300051 | 1573509366 | Python | Python (3.4.3) | py | Runtime Error | 349 | 15240 | 1292 | from collections import defaultdict
class UnionFind(object):
def __init__(self,n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(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 :
if self.rank[x] <self.rank[y]:
x,y = y,x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] +=self.size[y]
def is_same(self,x,y):
return self.find(x)==self.find(y)
def get_size(self,x):
x = self.find(x)
return self.size[x]
N, K, L = map(int, input().split())
# 道路のUnionFind
uf1 = UnionFind(N)
for i in range(K):
p, q = map(int, input().split())
uf1.union(p - 1, q - 1)
# 鉄道のUnionFind
uf2 = UnionFind(N)
for i in range(L):
r, s = map(int, input().split())
uf2.union(r - 1, s - 1)
# 道路と鉄道の連結の組み合わせ（根のペアのカウント）
c = defaultdict(int)
for i in range(N):
c[(uf1.find(i), uf2.find(i))] += 1
ans = ""
# 回答を出力
for i in range(N):
ans += str(c[(uf1.find(i), uf2.find(i))]) + " "
print(ans) |
s055556574 | p03855 | u099300051 | 1573509209 | Python | Python (3.4.3) | py | Runtime Error | 344 | 15236 | 1291 | from collections import defaultdict
class UnionFind(object):
def __init__(self,n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(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 :
if self.rank[x] <self.rank[y]:
x,y = y,x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] +=self.size[y]
def is_same(self,x,y):
return self.find(x)==self.find(y)
def get_size(self,x):
x = self.find(x)
return self.size[x]
N, K, L = map(int, input().split())
# 道路のUnionFind
uf1 = UnionFind(N)
for i in range(K):
p, q = map(int, input().split())
uf1.union(p - 1, q - 1)
# 鉄道のUnionFind
uf2 = UnionFind(N)
for i in range(L):
r, s = map(int, input().split())
uf2.union(r - 1, s - 1)
# 道路と鉄道の連結の組み合わせ（根のペアのカウント）
c = defaultdict(int)
for i in range(N):
c[(uf1.find(i), uf2.find(i))] += 1
ans = ""
# 回答を出力
for i in range(N):
ans += str(c[(uf1.find(i), uf2.find(i))]) + " "
print(ans) |
s277917692 | p03855 | u375870553 | 1573330674 | Python | Python (3.4.3) | py | Runtime Error | 119 | 24948 | 1232 | import sys
sys.setrecursionlimit(10**7)
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 = find(x); y = find(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
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]) |
s332714005 | p03855 | u375870553 | 1573330306 | Python | Python (3.4.3) | py | Runtime Error | 2214 | 685992 | 1341 | import sys
sys.setrecursionlimit(10**7)
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]) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.