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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
s868457179 | p02361 | u825008385 | 1523455912 | Python | Python3 | py | Runtime Error | 0 | 0 | 1247 | from memory_profiler import profile
# Single Source Shortest Path
infty = 99999
[vertex, edge, r] = list(map(int, input("").split()))
D = [[infty for j in range(vertex)] for i in range(vertex)]
for i in range(edge):
data = list(map(int, input("").split()))
D[data[0]][data[1]] = data[2]
@profile
def Dijkstra(root, n):
visited_order = 0
label = [0 for i in range(n)]
global D
global infty
d = D[root]
visited_order += 1
label[root] = visited_order
while visited_order < n:
min_cost = infty
for i in range(n):
if label[i] != 0:
continue
if min_cost > d[i]:
min_cost = d[i]
min_node = i
if min_cost == infty:
break
visited_order += 1
label[min_node] = visited_order
for i in range(n):
if label[i] != 0:
continue
if d[i] > d[min_node] + D[min_node][i]:
d[i] = d[min_node] + D[min_node][i]
del visited_order
del label
del D
del min_cost
d[root] = 0
return d
result = Dijkstra(r, vertex)
for i in range(vertex):
if result[i] == infty:
result[i] = "INF"
print(result[i])
|
s501486847 | p02361 | u825008385 | 1523455991 | Python | Python3 | py | Runtime Error | 20 | 5612 | 1202 | # Single Source Shortest Path
infty = 99999
[vertex, edge, r] = list(map(int, input("").split()))
D = [[infty for j in range(vertex)] for i in range(vertex)]
for i in range(edge):
data = list(map(int, input("").split()))
D[data[0]][data[1]] = data[2]
def Dijkstra(root, n):
visited_order = 0
label = [0 for i in range(n)]
global D
global infty
d = D[root]
visited_order += 1
label[root] = visited_order
while visited_order < n:
min_cost = infty
for i in range(n):
if label[i] != 0:
continue
if min_cost > d[i]:
min_cost = d[i]
min_node = i
if min_cost == infty:
break
visited_order += 1
label[min_node] = visited_order
for i in range(n):
if label[i] != 0:
continue
if d[i] > d[min_node] + D[min_node][i]:
d[i] = d[min_node] + D[min_node][i]
del visited_order
del label
del D
del min_cost
d[root] = 0
return d
result = Dijkstra(r, vertex)
for i in range(vertex):
if result[i] == infty:
result[i] = "INF"
print(result[i])
|
s593960884 | p02361 | u825008385 | 1523546392 | Python | Python3 | py | Runtime Error | 20 | 5620 | 1419 | # Single Source Shortest Path
infty = 99999
[vertex, edge, r] = list(map(int, input("").split()))
dict_r = {}
for i in range(vertex):
dict_r[(r,i)] = infty
dict_c = {}
for i in range(edge):
data = list(map(int, input("").split()))
if int(data[0]) == r:
dict_r[(data[0],data[1])] = int(data[2])
else:
dict_c[(data[0],data[1])] = int(data[2])
del data
def Dijkstra(root, n):
visited_order = 0
label = [0 for i in range(n)]
global dict_r, dict_c, infty
visited_order += 1
label[root] = visited_order
while visited_order < n:
min_cost = infty
for i in range(n):
if label[i] != 0:
continue
if min_cost > dict_r[(root, i)]:
min_cost = dict_r[(root, i)]
min_node = i
if min_cost == infty:
break
visited_order += 1
label[min_node] = visited_order
for i in range(n):
if label[i] != 0:
continue
if ((min_node, i) in dict_c.keys()) == True:
if dict_r[(root, i)] > dict_r[(root, min_node)] + dict_c[(min_node, i)]:
dict_r[(root, i)] = dict_r[(root, min_node)] + dict_c[(min_node, i)]
Dijkstra(r, vertex)
for i in range(vertex):
if r == i:
print(0)
elif dict_r[(r, i)] == infty:
print("INF")
else:
print(dict_r[(r, i)])
|
s321194101 | p02361 | u167493070 | 1523758349 | Python | Python3 | py | Runtime Error | 20 | 5748 | 1439 | import sys
import heapq
def dfs(u,s,target, vs):
vs[u] = 1
if(u == target):
global h
heapq.heappush(h,s)
return
for j in range(e):
if(e_1[j] == u):
if(vs[e_2[j]] != 1):
count = s + e_w[j]
print(s,e_2[j],vs)
dfs(e_2[j],count,target,vs[0:])
def dijsktra(start, v, e):
d = [0]*v
prev = [0]*v
v_q=[[] for i in range(v)];
INF = 9999999999999999999
for u in range(v):
if(u != start):
d[u] = INF
else:
d[u] = 0
prev[u] = -1
heapq.heappush(v_q[u],d[u])
while(True):
min = INF
for i in range(len(v_q)):
if(len(v_q[i]) != 0):
if(min > v_q[i][0]):
min = v_q[i][0]
u = i
heapq.heappop(v_q[u])
if(min == (INF)):
break
for j in range(e):
if(u == e_1[j]):
alt = d[u]+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
prev[e_2[j]] = u
heapq.heappush(v_q[e_2[j]],alt)
for i in range(v):
if(d[i] != INF):
print(d[i])
else:
print("INF")
v,e,r=map(int, input().split());
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = map(int, input().split());
dijsktra(r,v,e)
|
s555319078 | p02361 | u167493070 | 1523758432 | Python | Python3 | py | Runtime Error | 0 | 0 | 1478 | import sys
import heapq
def dfs(u,s,target, vs):
vs[u] = 1
if(u == target):
global h
heapq.heappush(h,s)
return
for j in range(e):
if(e_1[j] == u):
if(vs[e_2[j]] != 1):
count = s + e_w[j]
print(s,e_2[j],vs)
dfs(e_2[j],count,target,vs[0:])
def dijsktra(start, v, e):
d = [0]*v
prev = [0]*v
v_q=[[] for i in range(v)];
INF = 9999999999999999999
for u in range(v):
if(u != start):
d[u] = INF
else:
d[u] = 0
prev[u] = -1
heapq.heappush(v_q[u],d[u])
while(True):
min = INF
u = -1
for i in range(len(v_q)):
if(len(v_q[i]) != 0):
if(min > v_q[i][0]):
min = v_q[i][0]
u = i
if(u!=-1):
heapq.heappop(v_q[u])
if(min == (INF)):
break
for j in range(e):
if(u == e_1[j]):
alt = d[u]+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
prev[e_2[j]] = u
heapq.heappush(v_q[e_2[j]],alt)
for i in range(v):
if(d[i] != INF):
print(d[i])
else:
print("INF")
v,e,r=map(int, input().split());
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = map(int, input().split());
dijsktra(r,v,e)
|
s989608808 | p02361 | u167493070 | 1523759330 | Python | Python3 | py | Runtime Error | 0 | 0 | 1315 | import sys
import heapq
def dfs(u,s,target, vs):
vs[u] = 1
if(u == target):
global h
heapq.heappush(h,s)
return
for j in range(e):
if(e_1[j] == u):
if(vs[e_2[j]] != 1):
count = s + e_w[j]
print(s,e_2[j],vs)
dfs(e_2[j],count,target,vs[0:])
def dijsktra(start, v, e):
d = [0]*v
prev = [0]*v
v_q=[];
INF = 9999999999999999999
for u in range(v):
if(u != start):
d[u] = INF
else:
d[u] = 0
prev[u] = -1
heapq.heappush(v_q,(0,start))
heapq.heappush(v_q,(INF,0))
while(True):
cost,u = heapq.heappop(v_q)
if(cost > d[u]):
continue
if(cost == INF):
break
for j in range(e):
if(u == e_1[j]):
alt = d[u]+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
prev[e_2[j]] = u
heapq.heappush(v_q,(alt,e_2[j]))
for i in range(v):
if(d[i] != INF):
print(d[i])
else:
print("INF")
v,e,r=map(int, input().split());
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = map(int, input().split());
dijsktra(r,v,e)
|
s856725892 | p02361 | u167493070 | 1523760376 | Python | Python3 | py | Runtime Error | 0 | 0 | 465 | INF = 9999999999999999999
d = [INF for i in range(v)]
d[r] = 0
heapq.heappush(v_q,(0,r))
while(len(v_q) != 0):
cost,u = heapq.heappop(v_q)
if(cost > d[u]):
continue
for j in range(e):
if(u == e_1[j]):
alt = cost+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
heapq.heappush(v_q,(alt,e_2[j]))
for i in range(v):
if(d[i] != INF):
print(d[i])
else:
print("INF")
|
s872744914 | p02361 | u167493070 | 1528102894 | Python | Python3 | py | Runtime Error | 0 | 0 | 660 | import sys
from collections import deque
v,e,r=map(int, input().split());
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = map(int, input().split());
v_q=[];
INF = 9999999999999999999
d = [INF for i in range(v)]
d[r] = 0
heapq.heappush(v_q,(0,r))
while(len(v_q) != 0):
cost,u = heapq.heappop(v_q)
if(cost > d[u]):
continue
for j in range(e):
if(u == e_1[j]):
alt = cost+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
heapq.heappush(v_q,(alt,e_2[j]))
for i in range(v):
if(d[i] != INF):
print(d[i])
else:
print("INF")
|
s038825156 | p02361 | u167493070 | 1528102909 | Python | Python3 | py | Runtime Error | 0 | 0 | 641 | import sys
from heapq
v,e,r=map(int, input().split());
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = map(int, input().split());
v_q=[];
INF = 9999999999999999999
d = [INF for i in range(v)]
d[r] = 0
heapq.heappush(v_q,(0,r))
while(len(v_q) != 0):
cost,u = heapq.heappop(v_q)
if(cost > d[u]):
continue
for j in range(e):
if(u == e_1[j]):
alt = cost+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
heapq.heappush(v_q,(alt,e_2[j]))
for i in range(v):
if(d[i] != INF):
print(d[i])
else:
print("INF")
|
s139384417 | p02361 | u089116225 | 1529340734 | Python | Python3 | py | Runtime Error | 0 | 0 | 450 | V,E,r = map(int, input().split())
edges = []
for _ in range(E):
tmp = [int(x) for x in input().split()]
edges.append(tmp)
d = [float('inf') for _ in range(V)]
d[r] = 0
for _ in range(V-1):
count = 0
for x in edges:
s,t,d = x
if d[t] > d[s] + d:
count += 1
d[t] = d[s] + d
if count == 0:
break
for x in d:
if x == float('inf'):
print('INF')
else:
print(x)
|
s227200387 | p02362 | u871901071 | 1404086451 | Python | Python3 | py | Runtime Error | 0 | 0 | 857 | import sys
def shortestPath(graph, s):
n = len(graph)
dist = [inf for _ in range(n)]
dist[s] = 0
for i in range(n):
for u in range(n):
for v, cost in graph[u]:
newDist = dist[u] + cost
if dist[u] != inf and newDist < dist[v]:
if i == n - 1:
return None
dist[v] = newDist
return dist
def main():
v, e, s = map(int, input().split())
graph = [[] for _ in range(v)]
for i in range(e):
a, b, cost = map(int, input().split())
graph[a].append((b, cost))
dist = shortestPath(graph, s)
if not dist:
print("NEGATIVE CYCLE")
else:
for d in dist:
if d >= inf:
print("INF")
else:
print(d)
main() |
s374339174 | p02362 | u567380442 | 1427694806 | Python | Python3 | py | Runtime Error | 0 | 0 | 858 | class exist_negative_cycle(Exception):
pass
def bellman_ford(g, size, start=0):
d = [float('inf')] * size
d[start] = 0
for _ in range(size):
for u in g:
for length, v in g[u]:
if d[v] > d[u] + length:
d[v] = d[u] + length
for u in g:
for length, v in g[u]:
if d[v] > d[u] + length:
raise exist_negative_cycle
return d
from sys import stdin
readline = stdin.readline
from collections import defaultdict
vertex, edge, r = map(int, readline().split())
g = defaultdict(list)
for i in range(edge):
s, t, length = map(int, readline().split())
g[s].append((length, t))
try:
d = bellman_ford(g, vertex, r)
for di in d:
print('INF' if math.isinf(di) else di)
except exist_negative_cycle:
print('NEGATIVE CYCLE') |
s727560565 | p02362 | u442472098 | 1433241362 | Python | Python3 | py | Runtime Error | 0 | 0 | 548 | #!/usr/bin/env python3
from math import isinf
V, E, r = map(int, input().split())
vertices = [float('inf')] * V
vertices[r] = 0
edges = []
for i in range(E):
s, t, d = map(int, input().split())
edges.append((s, t, d))
for i in range(V - 1):
for s, t, d in edges:
if vertices[t] > vertices[s] + d:
vertices[t] = vertices[s] + d
for s, t, d in edges:
if vertices[t] > vertices[s] + d:
neg = True
print("NEGATIVE CYCLE")
if not neg:
for v in vertices:
print('INF' if isinf(v) else v) |
s903592549 | p02362 | u966364923 | 1451569884 | Python | Python3 | py | Runtime Error | 0 | 0 | 783 | V, E, root = map(int, input().split())
visited = [False] * V
nodes = [[] for i in range(V)]
cost = [[] for i in range(V)]
for i in range(E):
s, t, d = map(int, input().split())
nodes[s].append(t)
cost[s].append(d)
dist = [float('inf')] * V
dist[root] = 0
negative_cycle = False
for k in range(V):
for i in range(V):
for j in range(nodes[i]):
if dist[nodes[i][j]] > dist[i] + cost[i][j]:
dist[nodes[i][j]] = dist[i] + cost[i][j]
if k==n-1:
dist[nodes[i][j]] = -float('inf')
negative_cycle = True
if negative_cycle:
print('NEGATIVE CYCLE')
else:
for i in range(V):
if dist[i] == float('inf'):
print('INF')
else:
print(dist[i]) |
s746998718 | p02362 | u352394527 | 1528071924 | Python | Python3 | py | Runtime Error | 20 | 5600 | 848 |
INF = 10 ** 20
v_num, e_num, r = map(int, input().split())
dist_lst = [INF for _ in range(v_num)]
edges_lst = [[] for _ in range(e_num)]
negative_cycle_flag = False
for _ in range(e_num):
s, t, dist = map(int, input().split())
edges_lst[s].append((dist, t))
dist_lst[r] = 0
for _ in range(v_num):
for v in range(v_num):
if dist_lst[v] != INF:
for dist, to in edges_lst[v]:
if dist_lst[v] + dist < dist_lst[to]:
dist_lst[to] = dist_lst[v] + dist
for v in range(v_num):
if dist_lst[v] != INF:
for dist, to in edges_lst[v]:
if dist_lst[v] + dist < dist_lst[to]:
negative_cycle_flag = True
break
if negative_cycle_flag:
break
if negative_cycle_flag:
print("NEGATIVE CYCLE")
else:
for dist in dist_lst:
if dist == INF:
print("INF")
else:
print(dist)
|
s655507519 | p02363 | u397460030 | 1468758454 | Python | Python3 | py | Runtime Error | 50 | 7840 | 1491 | import heapq
def solve(num_v ,graph_data): # dict -> [[arr]]
solution = []
for i in range(num_v):
solution.append(partial_solve(i, graph_data))
return solution
def partial_solve(source,graph_data):
heap = [(0,source)]
partial_solution = [float("inf") for _ in range(4)]
while heap:
dist, target = heapq.heappop(heap)
if partial_solution[target] > dist:
if partial_solution[target] != float("inf"):
return ["negative"]
partial_solution[target] = dist
for edge in graph_data[target]:
heapq.heappush(heap, (dist+edge[1], edge[0]))
return partial_solution
def print_solution(solution):
if ["negative"] in solution:
print("NEGATIVE CYCLE")
else:
print_matrix(solution)
def print_matrix(solution):
for r in solution:
l = ""
for c in r:
l += str_cell(c) + " "
print(l[:-1])
def str_cell(cell):
if cell == float("inf"):
return "INF"
else:
return str(cell)
def main():
l = input().split()
V = int(l[0])
E = int(l[1])
graph = {}
for i in range(E):
l = input().split()
source = int(l[0])
target = int(l[1])
dist = int(l[2])
if source in graph:
graph[source].append((target, dist))
else:
graph[source] = [(target, dist)]
print_solution(solve(V, graph))
if __name__ == "__main__":
main() |
s759868690 | p02363 | u397460030 | 1468758592 | Python | Python3 | py | Runtime Error | 20 | 7828 | 1509 | import heapq
def solve(num_v ,graph_data): # dict -> [[arr]]
solution = []
for i in range(num_v):
solution.append(partial_solve(i, num_v, graph_data))
return solution
def partial_solve(source, num_v,graph_data):
heap = [(0,source)]
partial_solution = [float("inf") for _ in range(num_v)]
while heap:
dist, target = heapq.heappop(heap)
if partial_solution[target] > dist:
if partial_solution[target] != float("inf"):
return ["negative"]
partial_solution[target] = dist
for edge in graph_data[target]:
heapq.heappush(heap, (dist+edge[1], edge[0]))
return partial_solution
def print_solution(solution):
if ["negative"] in solution:
print("NEGATIVE CYCLE")
else:
print_matrix(solution)
def print_matrix(solution):
for r in solution:
l = ""
for c in r:
l += str_cell(c) + " "
print(l[:-1])
def str_cell(cell):
if cell == float("inf"):
return "INF"
else:
return str(cell)
def main():
l = input().split()
V = int(l[0])
E = int(l[1])
graph = {}
for i in range(E):
l = input().split()
source = int(l[0])
target = int(l[1])
dist = int(l[2])
if source in graph:
graph[source].append((target, dist))
else:
graph[source] = [(target, dist)]
print_solution(solve(V, graph))
if __name__ == "__main__":
main() |
s487215530 | p02363 | u397460030 | 1469103786 | Python | Python3 | py | Runtime Error | 30 | 7784 | 1411 | def print_solve(ans):
if "negative" in ans:
print("NEGATIVE CYCLE")
else:
for l in ans:
for c in l[:-1]:
if c == float("inf"):
print("INF",end=" ")
else:
print(c,end=" ")
print(l[-1])
def solve(graph_data, num_v):
ans = []
for i in range(num_v):
ans.append(partial_solve(graph_data, i, num_v))
return ans
def partial_solve(graph_data, source, num_v):
ans = [0 if i == source else float('inf') for i in range(num_v)]
i = 0
while (ans != solver_iteration(graph_data, ans)):
ans = solver_iteration(graph_data, ans)
i += 1
if i >= num_v:
return "negative"
return ans
def solver_iteration(graph_data, prev_ans):
new_ans = prev_ans[0:]
for i, v in enumerate(new_ans):
if v == float('inf'):
continue
for t, w in graph_data[i]:
new_ans[t] = min(new_ans[t], v + w)
return new_ans
def main():
l = input().split()
V = int(l[0])
E = int(l[1])
graph = {}
for i in range(E):
l = input().split()
s = int(l[0])
t = int(l[1])
d = int(l[2])
if s in graph:
graph[s].append((t,d))
else:
graph[s] = [(t,d)]
print_solve(solve(graph, V))
if __name__ == "__main__":
main() |
s828578532 | p02363 | u022407960 | 1480178506 | Python | Python3 | py | Runtime Error | 30 | 7712 | 1318 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
def generate_adj_table(v_table):
for each in v_table:
start, end, weight = map(int, each)
init_adj_table[start][end] = weight
return init_adj_table
def floyd():
for k in _range:
for i in _range:
if adj_table[i].get(k) is None:
adj_table[i][k] = float('INF')
continue
for j in _range:
if adj_table[k].get(j) is None:
adj_table[k][j] = float("INF")
continue
adj_table[i][j] = min(adj_table[i][j], adj_table[i][k] + adj_table[k][j])
return adj_table
def solve():
ans = floyd()
negative = False
for m in range(vertices):
if ans[m][m] < 0:
negative = True
if negative:
print('NEGATIVE CYCLE')
else:
for a in _range:
print(*(str(each[-1]).upper() for each in sorted(ans[a].items())))
return None
if __name__ == '__main__':
_input = stdin.readlines()
vertices, edges = map(int, _input[0].split())
info_list = map(lambda x: x.split(), _input[1:])
_range = range(vertices)
init_adj_table = tuple({i: 0} for i in range(vertices))
adj_table = generate_adj_table(info_list)
solve() |
s236929037 | p02363 | u798803522 | 1486974937 | Python | Python3 | py | Runtime Error | 0 | 0 | 903 | from collections import defaultdict
vertice,edge = map(int,input().split(" "))
cost = [[0 if m == n else float("inf") for n in range(vertice)] for m in range(vertice)]
link = defaultdict(dict)
weight = defaultdict(dict)
for e in range(edge):
i,j,w = map(int,input().split(""))
link[i] = link.get(i,set()) | {j}
weight[i].update({j:w})
vertice_cnt = 0
while 1:
if vertice_cnt >= vertice:
print("NEGATIVE CYCLE")
break
update = False
for source in range(vertice)
for k,value in link.items():
for v in value:
if cost[source][v] > cost[source][k] + weight[k][v]:
cost[source][v] = cost[source][k] + weight[k][v]
update = True
if not update:
for o in range(vertice):
print(*([n if n != float("INF") else "INF" for n in cost[o]]))
break
vertice_cnt += 1 |
s809618441 | p02363 | u798803522 | 1486974978 | Python | Python3 | py | Runtime Error | 0 | 0 | 904 | from collections import defaultdict
vertice,edge = map(int,input().split(" "))
cost = [[0 if m == n else float("inf") for n in range(vertice)] for m in range(vertice)]
link = defaultdict(dict)
weight = defaultdict(dict)
for e in range(edge):
i,j,w = map(int,input().split(""))
link[i] = link.get(i,set()) | {j}
weight[i].update({j:w})
vertice_cnt = 0
while 1:
if vertice_cnt >= vertice:
print("NEGATIVE CYCLE")
break
update = False
for source in range(vertice):
for k,value in link.items():
for v in value:
if cost[source][v] > cost[source][k] + weight[k][v]:
cost[source][v] = cost[source][k] + weight[k][v]
update = True
if not update:
for o in range(vertice):
print(*([n if n != float("INF") else "INF" for n in cost[o]]))
break
vertice_cnt += 1 |
s410898245 | p02363 | u798803522 | 1507967565 | Python | Python3 | py | Runtime Error | 0 | 0 | 892 | from collections import defaultdict
vertices, edges = (int(n) for n in input().split(" "))
connect = defaultdict(list)
cost_dp = [[float("inf") if n != m else 0 for n in range(vertices)] for m in range(vertices)]
for e in range(edges):
v1, v2, weight = (int(n) for n in input().split(" "))
connect[v1].append([v2,weight])
connect[v2].append([v1,weight])
cost_dp[v1][v2] = weight
for neg in range(2):
updated = 0
for t in range(vertices + 1):
for i in range(vertices):
for k in range(vertices):
if cost_dp[i][k] > cost_dp[i][t] + cost_dp[t][k]:
updated = 1
cost_dp[i][k] = cost_dp[i][t] + cost_dp[t][k]
if neg == 1 and updated:
print("NEGATIVE CYCLE")
else:
for ve in range(vertices):
ans = ["INF" if n == float("inf") else n for n in cost_dp[ve]]
print(*ans)
break |
s037692375 | p02363 | u798803522 | 1507967691 | Python | Python3 | py | Runtime Error | 0 | 0 | 888 | from collections import defaultdict
vertices, edges = (int(n) for n in input().split(" "))
connect = defaultdict(list)
cost_dp = [[float("inf") if n != m else 0 for n in range(vertices)] for m in range(vertices)]
for e in range(edges):
v1, v2, weight = (int(n) for n in input().split(" "))
connect[v1].append([v2,weight])
connect[v2].append([v1,weight])
cost_dp[v1][v2] = weight
for neg in range(2):
updated = 0
for t in range(vertices):
for i in range(vertices):
for k in range(vertices):
if cost_dp[i][k] > cost_dp[i][t] + cost_dp[t][k]:
updated = 1
cost_dp[i][k] = cost_dp[i][t] + cost_dp[t][k]
if neg == 1 and updated:
print("NEGATIVE CYCLE")
else:
for ve in range(vertices):
ans = ["INF" if n == float("inf") else n for n in cost_dp[ve]]
print(*ans)
break |
s220587712 | p02363 | u146816547 | 1510482876 | Python | Python | py | Runtime Error | 0 | 0 | 986 | def main():
INF = int(1e12)
G = [[0 for i in range(101)] for j in range(101)];
v, e = map(int, raw_input().split())
for i in range(v):
for j in range(v):
if i == j:
G[i][j] = 0
else:
G[i][j] = INF
for i in range(e):
s, t, d = map(int, raw_input().split())
G[s][t] = d
for k in range(v):
for i in range(v):
c2 = G[i][k]
for j, (c1, c3) in enumerate(zip(G[i], G[k])):
if ci > c2 + c3:
G[i][j] = c2 + c3
G[i][j] = min(G[i][j], G[i][k] + G[k][j])
for i in range(v):
if G[i][i] < 0:
print "NEGATIVE CYCLE"
return 0
for i in range(v):
ans = []
for j in range(v):
if G[i][j] == INF:
ans.append("INF")
else:
ans.append(G[i][j])
print " ".join(map(str, ans))
main() |
s251032147 | p02363 | u146816547 | 1510482918 | Python | Python | py | Runtime Error | 0 | 0 | 931 | def main():
INF = int(1e12)
G = [[0 for i in range(101)] for j in range(101)];
v, e = map(int, raw_input().split())
for i in range(v):
for j in range(v):
if i == j:
G[i][j] = 0
else:
G[i][j] = INF
for i in range(e):
s, t, d = map(int, raw_input().split())
G[s][t] = d
for k in range(v):
for i in range(v):
c2 = G[i][k]
for j, (c1, c3) in enumerate(zip(G[i], G[k])):
if ci > c2 + c3:
G[i][j] = c2 + c3
for i in range(v):
if G[i][i] < 0:
print "NEGATIVE CYCLE"
return 0
for i in range(v):
ans = []
for j in range(v):
if G[i][j] == INF:
ans.append("INF")
else:
ans.append(G[i][j])
print " ".join(map(str, ans))
main() |
s560650720 | p02364 | u131811591 | 1531698670 | Python | Python3 | py | Runtime Error | 0 | 0 | 1106 | import sys
from union_find import UnionFind
from operator import attrgetter
class Kruskal:
class Edge:
def __init__(self, u, v, cost):
self.u, self.v, self.cost = u, v, cost
def __lt__(self, another):
return self.cost < another.cost
def __init__(self, node_size):
self._node = node_size
self._edge_list = []
def add_edge(self, u, v, cost):
self._edge_list.append(self.Edge(u, v, cost))
def solve(self):
uf = UnionFind(self._node)
res = 0
edge_count = 0
sorted_edge_list = sorted(self._edge_list)
for e in sorted_edge_list:
if not uf.same(e.u, e.v):
uf.unite(e.u, e.v)
res += e.cost
edge_count += 1
if edge_count == self._node-1:
break
return res
if __name__ == '__main__':
n, m = map(int, sys.stdin.readline().split())
kr = Kruskal(n)
for _ in range(m):
s, t, w = map(int, sys.stdin.readline().split())
kr.add_edge(s, t, w)
print(kr.solve())
|
s896088028 | p02364 | u629780968 | 1545454370 | Python | Python3 | py | Runtime Error | 0 | 0 | 610 | n = int(input())
m = [[-1 for i in range (n)] for j in range(n)]
d = [0]+ [2000]* (n-1)
isVisited = [False] * n
for i in range(n):
nums = list(map(int, input().split()))
for j in range(n):
m[i][j] = nums[j]
# def prim_mst(n):
def prim_mst(n):
while True:
mincost = 2000
for i in range(n):
if (not isVisited[i]) and (d[i] < mincost):
mincost = d[i]
u = i
isVisited[u] = True
if mincost == 2000:
break
for v in range(n):
if (not isVisited[v]) and (m[u][v] != -1):
if m[u][v] < d[v]:
d[v] = m[u][v]
print(d)
prim_mst(n)
|
s047730740 | p02364 | u629780968 | 1545454935 | Python | Python3 | py | Runtime Error | 0 | 0 | 851 | n = int(input())
m = [[-1 for i in range(n)] for j in range(n)] #お隣さんへのコストを保存（この中から最小を探す）
v = set()
v.add(0)
for i in range(n): #隣接の辺のコストを入力
nums = list(map(int, input().split()))
for j in range(n):
m[i][j] = nums[j]
def prim_mst(n):
isVisited = [False] * n
d = [0] + [2001] * (n-1) #TとV-Tのを繋ぐ最小辺の重みを格納する
while True:
mincost = 2001
for i in range(n):
if not (isVisited[i]) and d[i] < mincost:
mincost = d[i]
u = i
isVisited[u] = True
if mincost == 2001: #mincostが2001になったら繰り返し作業終了
break
for v in range (n):
if (not isVisited[v]) and (m[u][v] != -1):
if m[u][v] < d[v]:
d[v] = m[u][v]
print(sum(d))
prim_mst(n)
|
s290488990 | p02364 | u943441430 | 1559194638 | Python | Python3 | py | Runtime Error | 20 | 5664 | 962 | from heapq import heappush, heappop
line = input()
v, e = list(map(int, line.split()))
edge = {}
for _ in range(0, e):
line = input()
s, t, w = list(map(int, line.split()))
if s not in edge:
edge[s] = [[t, w]]
else:
edge[s] += [[t, w]]
if t not in edge:
edge[t] = [[s, w]]
else:
edge[t] += [[s, w]]
def solve(v, edge):
q = []
vtx = set([i for i in range(0, v)])
for t, w in edge[0]:
heappush(q, (w, 0, t))
vn = set([0])
en = []
cost = 0
while len(vn) < v:
w = s = t = 0
qq = []
while q:
w, s, t = heappop(q)
if s in vn and t not in vn:
s, t = t, s
break
if s not in vn and t in vn:
break
vn.add(s)
en += [(s, t)]
cost += w
for t, w in edge[s]:
heappush(q, (w, s, t))
return cost
print(solve(v, edge))
|
s096901846 | p02364 | u686180487 | 1559355770 | Python | Python3 | py | Runtime Error | 0 | 0 | 544 | # -*- coding: utf-8 -*-
V, E = list(map(int, input().split()))
weight = []
for i in range(E):
s, t, w = list(map(int, input().split()))
weight.append((s,t,w))
weight.sort(key = lambda x: x[2])
parent = [i for i in range(V)]
def find(x):
if parent[x] == x:
return x
else:
return find(parent[x])
def union(x, y):
a = find(x)
b = find(y)
parent[a] = b
sum_weight = 0
while weight:
a, b, c = weight[0]
if find(a) != find(b):
union(a, b)
sum_weight += c
weight.pop(index=0)
print(sum_weight)
|
s229423508 | p02364 | u797673668 | 1455720460 | Python | Python3 | py | Runtime Error | 20 | 7744 | 562 | import heapq
nv, ne = map(int, input().split())
edges = [set() for _ in range(nv)]
while ne:
s, t, w = map(int, input().split())
edges[s].add((w, t))
edges[t].add((w, s))
ne -= 1
cost = 0
queue = list(edges[0])
heapq.heapify(queue)
visited = [False] * nv
visited[0] = True
while True:
edge_cost, t = heapq.heappop(queue)
if visited[t]:
continue
visited[t] = True
cost += edge_cost
if all(visited):
break
for e in edges[t]:
if not visited[e[1]]:
heapq.heappush(queue, e)
print(cost) |
s915397639 | p02364 | u766163292 | 1459318669 | Python | Python3 | py | Runtime Error | 0 | 0 | 1428 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import collections
import heapq
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim?????§??????0?????????????°???¨?????¨????±???????
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
# ??????????????????????????????????????\?????¨????????¨??????
pq = []
for v in range(max_v):
heapq.heappush(pq, (key[v], v))
while pq:
_, u = heapq.heappop(pq)
for v, v_cost in adj_list[u]:
if v in (item[1] for item in pq):
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
return (pred, key)
def main():
max_v, max_e = map(int, input().split())
adjacency_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = map(int, input().split())
adjacency_list[s].add(AdjacentVertex(t, w))
adjacency_list[t].add(AdjacentVertex(s, w))
#(_, key) = compute_mst_prim(max_v, adjacency_list)
print(sum(key.values()))
if __name__ == '__main__':
main() |
s039775401 | p02364 | u798803522 | 1487230887 | Python | Python3 | py | Runtime Error | 30 | 7900 | 984 | from collections import defaultdict
import heapq
vertices,edges = map(int,input().split(" "))
link = defaultdict(dict)
weight = defaultdict(dict)
for e in range(edges):
source,target,w = map(int,input().split(" "))
link[source] = link.get(source,set()) | {target}
link[target] = link.get(target,set()) | {source}
weight[source].update({target:w})
weight[target].update({source:w})
queue = []
heapq.heapify(queue)
heapq.heappush(queue,[0,0])
went = set()
now_weight = 0
while len(went) < vertices:
now_weight,here = heapq.heappop(queue)
#print(now_weight,here)
can_go = link[here] - went
min_weight,next_t = float("inf"),-1
for c in can_go:
if min_weight > now_weight + weight[here][c]:
min_weight = now_weight + weight[here][c]
next_t = c
#heapq.heappush(queue,[now_weight + weight[here][c],c])
heapq.heappush(queue,[min_weight,next_t])
#print(queue)
went = went | {here}
print(now_weight) |
s295276899 | p02364 | u798803522 | 1487233494 | Python | Python3 | py | Runtime Error | 0 | 0 | 1038 | from collections import defaultdict
import heapq
vertices,edges = map(int,input().split(" "))
link = defaultdict(dict)
weight = defaultdict(dict)
way = [float("inf")] * vertices
for e in range(edges):
source,target,w = map(int,input().split(" "))
link[source] = link.get(source,set()) | {target}
link[target] = link.get(target,set()) | {source}
weight[source].update({target:w})
weight[target].update({source:w})
queue = []
heapq.heapify(queue)
heapq.heappush(queue,[0,0])
went = set()
now_weight = 0
way[0] = 0
while len(went) < vertices:
here_weight,here = heapq.heappop(queue)
#print(now_weight,here)
now_weight += here_weight
can_go = link.get(here,set()) - went
min_weight,next_t = float("inf"),-1
for c in can_go:
#heapq.heappush(queue,[now_weight + weight[here][c],c])
if c not in went and way[c] > [weight[here][c]:
heapq.heappush(queue,[weight[here][c],c])
way[c] = [weight[here][c]
#print(queue)
went = went | {here}
print(now_weight) |
s147338420 | p02364 | u798803522 | 1487238471 | Python | Python3 | py | Runtime Error | 0 | 0 | 1214 | from collections import defaultdict
import heapq
def aaa()
vertices,edges = map(int,input().split(" "))
link = defaultdict(dict)
weight = defaultdict(dict)
way = [float("inf")] * vertices
for e in range(edges):
source,target,w = map(int,input().split(" "))
link[source] = link.get(source,set()) | {target}
link[target] = link.get(target,set()) | {source}
weight[source].update({target:w})
weight[target].update({source:w})
queue = []
heapq.heapify(queue)
heapq.heappush(queue,[0,0])
went = [0] * vertices
now_weight = 0
way[0] = 0
while len(went) < vertices:
here_weight,here = heapq.heappop(queue)
if here in went:
continue
#print(now_weight,here)
went[here] = 1
now_weight += here_weight
can_go = link.get(here,set()) - went
min_weight,next_t = float("inf"),-1
for c in can_go:
#heapq.heappush(queue,[now_weight + weight[here][c],c])
if c not in went and way[c] > weight[here][c]:
heapq.heappush(queue,[weight[here][c],c])
way[c] = weight[here][c]
#print(queue)
print(now_weight) |
s242314772 | p02364 | u035108350 | 1500340429 | Python | Python3 | py | Runtime Error | 0 | 0 | 4955 |
class Node:
def __init__(self):
pass
class Edge:
def __init__(self,edge,cost=1):
self.node_from=edge[0]
self.node_to=edge[1]
self.cost=cost
def add_node(self,node):
self.nodes.append(node)
class myGraph:
def __init__(self):
self.adj={}
self.nodes={}
def add_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
# add the edge
self.adj[u][v] = cost
self.adj[v][u] = cost
def add_directed_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
self.adj[u][v] = cost
def get_edges_from(self,node):
return [(self.adj[node][nn],node,nn) for nn in self.adj[node]]
def makeEdgeobj(self):
edges=[]
for sn in self.nodes:
for e in self.get_edges_from(sn):
edges.append(Edge([e[1],e[2]],e[0]))
return edges
def _add(self,edges,add_edges):
for e in add_edges:
hq.heappush(edges,e)
return edges
def bermn_ford(self,start,init=0):
nodes=self.nodes
dists={}
for n in nodes:
dists[n]=float("inf")
dists[start]=init
edges=self.makeEdgeobj()
for i in range(len(nodes)):
update=False
for k in range(len(edges)):
e=edges[k]
if dists[e.node_from]!=float("inf") and dists[e.node_to]>dists[e.node_from]+e.cost:
dists[e.node_to]=dists[e.node_from]+e.cost
update=True
if i==len(nodes)-1:
return False
if not update:
break
return dists
def dijkstra(self,start, goal=None):
import heapq
'''
get minimum cost
'''
N = len(self.adj) # ??°????????????????????°
#dist = [float('inf') for i in range(N)] # ?§????????????????????????§??????????????¢???????´???????
dist = {k:float('inf') for k in self.nodes}
#prev = [float('inf') for i in range(N)]
dist[start] = 0
visited = []
koho=[]
heapq.heappush(koho,(0,start))
vtx=list(self.nodes)
vtx.remove(start)
while len(koho)!=0:
d,mini=heapq.heappop(koho)
if dist[mini]<d:
continue
for k in list(self.adj[mini]):
cost=self.adj[mini][k]
if cost != float('inf') and dist[k]>dist[mini]+cost:# and not(k in visited):
dist[k]=dist[mini]+cost
heapq.heappush(koho,(dist[k],k))
#prev[k]=mini
return dist
def prim(self):
import heapq
nodes=list(self.nodes.keys())
N=len(nodes)
X=[nodes[0]]
unused=[]
for u in self.adj[X[0]]:
heapq.heappush(unused,(u,self.adj[X[0]][u]))
total_cost=0
while True:
v,cost=heapq.heappop(unused)
X.append(v)
total_cost+=cost
if len(X)==N:
break
for u in self.adj[v]:
heapq.heappush(unused,(u,self.adj[v][u]))
return total_cost
def show(self):
import networkx as nx
import matplotlib.pyplot as plt
G=nx.Graph()
for e in self.edges:
G.add_edge(e.node_from,e.node_to,weight=e.cost)
#print(e.node_from,e.node_to,e.cost)
pos=nx.spring_layout(G)
#nx.draw_networkx_edges(G,pos=pos,edgelist=G.edges())
edge_weight=dict([((u,v,),int(d['weight'])) for u,v,d in G.edges(data=True)])
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_weight)
#nx.draw_networkx_labels(G, pos)
nx.draw_networkx_nodes(G,pos)
nx.draw_networkx_edges(G,pos)
nx.draw_networkx_labels(G,pos)
#plt.axis('off')
#nx.draw(G,with_labels=True)
plt.show()
def spaceinput():
s=input()
if len(s)==0:
return False
return list(map(int,s.split(" ")))
if __name__=="__main__":
a=spaceinput()
g=myGraph()
for i in range(9):
ss=spaceinput()
if not ss:
break
g.add_edge((ss[0],ss[1]),ss[2])
print(g.prim())
'''
d=g.dijkstra(1)
'''
'''
mint=10*9
for k in range(1,n+1):
dd=g.dijkstra(k)
v=max(dd.values())
if mint>v:
mint=v
print(mint)
''' |
s952166354 | p02364 | u035108350 | 1500340475 | Python | Python3 | py | Runtime Error | 0 | 0 | 4955 |
class Node:
def __init__(self):
pass
class Edge:
def __init__(self,edge,cost=1):
self.node_from=edge[0]
self.node_to=edge[1]
self.cost=cost
def add_node(self,node):
self.nodes.append(node)
class myGraph:
def __init__(self):
self.adj={}
self.nodes={}
def add_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
# add the edge
self.adj[u][v] = cost
self.adj[v][u] = cost
def add_directed_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
self.adj[u][v] = cost
def get_edges_from(self,node):
return [(self.adj[node][nn],node,nn) for nn in self.adj[node]]
def makeEdgeobj(self):
edges=[]
for sn in self.nodes:
for e in self.get_edges_from(sn):
edges.append(Edge([e[1],e[2]],e[0]))
return edges
def _add(self,edges,add_edges):
for e in add_edges:
hq.heappush(edges,e)
return edges
def bermn_ford(self,start,init=0):
nodes=self.nodes
dists={}
for n in nodes:
dists[n]=float("inf")
dists[start]=init
edges=self.makeEdgeobj()
for i in range(len(nodes)):
update=False
for k in range(len(edges)):
e=edges[k]
if dists[e.node_from]!=float("inf") and dists[e.node_to]>dists[e.node_from]+e.cost:
dists[e.node_to]=dists[e.node_from]+e.cost
update=True
if i==len(nodes)-1:
return False
if not update:
break
return dists
def dijkstra(self,start, goal=None):
import heapq
'''
get minimum cost
'''
N = len(self.adj) # ??°????????????????????°
#dist = [float('inf') for i in range(N)] # ?§????????????????????????§??????????????¢???????´???????
dist = {k:float('inf') for k in self.nodes}
#prev = [float('inf') for i in range(N)]
dist[start] = 0
visited = []
koho=[]
heapq.heappush(koho,(0,start))
vtx=list(self.nodes)
vtx.remove(start)
while len(koho)!=0:
d,mini=heapq.heappop(koho)
if dist[mini]<d:
continue
for k in list(self.adj[mini]):
cost=self.adj[mini][k]
if cost != float('inf') and dist[k]>dist[mini]+cost:# and not(k in visited):
dist[k]=dist[mini]+cost
heapq.heappush(koho,(dist[k],k))
#prev[k]=mini
return dist
def prim(self):
import heapq
nodes=list(self.nodes.keys())
N=len(nodes)
X=[nodes[0]]
unused=[]
for u in self.adj[X[0]]:
heapq.heappush(unused,(u,self.adj[X[0]][u]))
total_cost=0
while True:
v,cost=heapq.heappop(unused)
X.append(v)
total_cost+=cost
if len(X)==N:
break
for u in self.adj[v]:
heapq.heappush(unused,(u,self.adj[v][u]))
return total_cost
def show(self):
import networkx as nx
import matplotlib.pyplot as plt
G=nx.Graph()
for e in self.edges:
G.add_edge(e.node_from,e.node_to,weight=e.cost)
#print(e.node_from,e.node_to,e.cost)
pos=nx.spring_layout(G)
#nx.draw_networkx_edges(G,pos=pos,edgelist=G.edges())
edge_weight=dict([((u,v,),int(d['weight'])) for u,v,d in G.edges(data=True)])
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_weight)
#nx.draw_networkx_labels(G, pos)
nx.draw_networkx_nodes(G,pos)
nx.draw_networkx_edges(G,pos)
nx.draw_networkx_labels(G,pos)
#plt.axis('off')
#nx.draw(G,with_labels=True)
plt.show()
def spaceinput():
s=input()
if len(s)==0:
return False
return list(map(int,s.split(" ")))
if __name__=="__main__":
a=spaceinput()
g=myGraph()
for i in range(9):
ss=spaceinput()
if not ss:
break
g.add_edge((ss[0],ss[1]),ss[2])
print(g.prim())
'''
d=g.dijkstra(1)
'''
'''
mint=10*9
for k in range(1,n+1):
dd=g.dijkstra(k)
v=max(dd.values())
if mint>v:
mint=v
print(mint)
''' |
s458518479 | p02364 | u035108350 | 1500340581 | Python | Python3 | py | Runtime Error | 0 | 0 | 4957 |
class Node:
def __init__(self):
pass
class Edge:
def __init__(self,edge,cost=1):
self.node_from=edge[0]
self.node_to=edge[1]
self.cost=cost
def add_node(self,node):
self.nodes.append(node)
class myGraph:
def __init__(self):
self.adj={}
self.nodes={}
def add_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
# add the edge
self.adj[u][v] = cost
self.adj[v][u] = cost
def add_directed_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
self.adj[u][v] = cost
def get_edges_from(self,node):
return [(self.adj[node][nn],node,nn) for nn in self.adj[node]]
def makeEdgeobj(self):
edges=[]
for sn in self.nodes:
for e in self.get_edges_from(sn):
edges.append(Edge([e[1],e[2]],e[0]))
return edges
def _add(self,edges,add_edges):
for e in add_edges:
hq.heappush(edges,e)
return edges
def bermn_ford(self,start,init=0):
nodes=self.nodes
dists={}
for n in nodes:
dists[n]=float("inf")
dists[start]=init
edges=self.makeEdgeobj()
for i in range(len(nodes)):
update=False
for k in range(len(edges)):
e=edges[k]
if dists[e.node_from]!=float("inf") and dists[e.node_to]>dists[e.node_from]+e.cost:
dists[e.node_to]=dists[e.node_from]+e.cost
update=True
if i==len(nodes)-1:
return False
if not update:
break
return dists
def dijkstra(self,start, goal=None):
import heapq
'''
get minimum cost
'''
N = len(self.adj) # ??°????????????????????°
#dist = [float('inf') for i in range(N)] # ?§????????????????????????§??????????????¢???????´???????
dist = {k:float('inf') for k in self.nodes}
#prev = [float('inf') for i in range(N)]
dist[start] = 0
visited = []
koho=[]
heapq.heappush(koho,(0,start))
vtx=list(self.nodes)
vtx.remove(start)
while len(koho)!=0:
d,mini=heapq.heappop(koho)
if dist[mini]<d:
continue
for k in list(self.adj[mini]):
cost=self.adj[mini][k]
if cost != float('inf') and dist[k]>dist[mini]+cost:# and not(k in visited):
dist[k]=dist[mini]+cost
heapq.heappush(koho,(dist[k],k))
#prev[k]=mini
return dist
def prim(self):
import heapq
nodes=list(self.nodes.keys())
N=len(nodes)
X=[nodes[0]]
unused=[]
for u in self.adj[X[0]]:
heapq.heappush(unused,(u,self.adj[X[0]][u]))
total_cost=0
while True:
v,cost=heapq.heappop(unused)
X.append(v)
total_cost+=cost
if len(X)==N:
break
for u in self.adj[v]:
heapq.heappush(unused,(u,self.adj[v][u]))
return total_cost
def show(self):
import networkx as nx
import matplotlib.pyplot as plt
G=nx.Graph()
for e in self.edges:
G.add_edge(e.node_from,e.node_to,weight=e.cost)
#print(e.node_from,e.node_to,e.cost)
pos=nx.spring_layout(G)
#nx.draw_networkx_edges(G,pos=pos,edgelist=G.edges())
edge_weight=dict([((u,v,),int(d['weight'])) for u,v,d in G.edges(data=True)])
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_weight)
#nx.draw_networkx_labels(G, pos)
nx.draw_networkx_nodes(G,pos)
nx.draw_networkx_edges(G,pos)
nx.draw_networkx_labels(G,pos)
#plt.axis('off')
#nx.draw(G,with_labels=True)
plt.show()
def spaceinput():
s=input()
if len(s)==0:
return False
return list(map(int,s.split(" ")))
if __name__=="__main__":
a=spaceinput()
g=myGraph()
for i in range(999):
ss=spaceinput()
if not ss:
break
g.add_edge((ss[0],ss[1]),ss[2])
print(g.prim())
'''
d=g.dijkstra(1)
'''
'''
mint=10*9
for k in range(1,n+1):
dd=g.dijkstra(k)
v=max(dd.values())
if mint>v:
mint=v
print(mint)
''' |
s447300525 | p02364 | u035108350 | 1500340632 | Python | Python3 | py | Runtime Error | 0 | 0 | 4957 |
class Node:
def __init__(self):
pass
class Edge:
def __init__(self,edge,cost=1):
self.node_from=edge[0]
self.node_to=edge[1]
self.cost=cost
def add_node(self,node):
self.nodes.append(node)
class myGraph:
def __init__(self):
self.adj={}
self.nodes={}
def add_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
# add the edge
self.adj[u][v] = cost
self.adj[v][u] = cost
def add_directed_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
self.adj[u][v] = cost
def get_edges_from(self,node):
return [(self.adj[node][nn],node,nn) for nn in self.adj[node]]
def makeEdgeobj(self):
edges=[]
for sn in self.nodes:
for e in self.get_edges_from(sn):
edges.append(Edge([e[1],e[2]],e[0]))
return edges
def _add(self,edges,add_edges):
for e in add_edges:
hq.heappush(edges,e)
return edges
def bermn_ford(self,start,init=0):
nodes=self.nodes
dists={}
for n in nodes:
dists[n]=float("inf")
dists[start]=init
edges=self.makeEdgeobj()
for i in range(len(nodes)):
update=False
for k in range(len(edges)):
e=edges[k]
if dists[e.node_from]!=float("inf") and dists[e.node_to]>dists[e.node_from]+e.cost:
dists[e.node_to]=dists[e.node_from]+e.cost
update=True
if i==len(nodes)-1:
return False
if not update:
break
return dists
def dijkstra(self,start, goal=None):
import heapq
'''
get minimum cost
'''
N = len(self.adj) # ??°????????????????????°
#dist = [float('inf') for i in range(N)] # ?§????????????????????????§??????????????¢???????´???????
dist = {k:float('inf') for k in self.nodes}
#prev = [float('inf') for i in range(N)]
dist[start] = 0
visited = []
koho=[]
heapq.heappush(koho,(0,start))
vtx=list(self.nodes)
vtx.remove(start)
while len(koho)!=0:
d,mini=heapq.heappop(koho)
if dist[mini]<d:
continue
for k in list(self.adj[mini]):
cost=self.adj[mini][k]
if cost != float('inf') and dist[k]>dist[mini]+cost:# and not(k in visited):
dist[k]=dist[mini]+cost
heapq.heappush(koho,(dist[k],k))
#prev[k]=mini
return dist
def prim(self):
import heapq
nodes=list(self.nodes.keys())
N=len(nodes)
X=[nodes[0]]
unused=[]
for u in self.adj[X[0]]:
heapq.heappush(unused,(u,self.adj[X[0]][u]))
total_cost=0
while True:
v,cost=heapq.heappop(unused)
X.append(v)
total_cost+=cost
if len(X)==N:
break
for u in self.adj[v]:
heapq.heappush(unused,(u,self.adj[v][u]))
return total_cost
def show(self):
import networkx as nx
import matplotlib.pyplot as plt
G=nx.Graph()
for e in self.edges:
G.add_edge(e.node_from,e.node_to,weight=e.cost)
#print(e.node_from,e.node_to,e.cost)
pos=nx.spring_layout(G)
#nx.draw_networkx_edges(G,pos=pos,edgelist=G.edges())
edge_weight=dict([((u,v,),int(d['weight'])) for u,v,d in G.edges(data=True)])
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_weight)
#nx.draw_networkx_labels(G, pos)
nx.draw_networkx_nodes(G,pos)
nx.draw_networkx_edges(G,pos)
nx.draw_networkx_labels(G,pos)
#plt.axis('off')
#nx.draw(G,with_labels=True)
plt.show()
def spaceinput():
s=input()
if len(s)==0:
return False
return list(map(int,s.split(" ")))
if __name__=="__main__":
a=spaceinput()
g=myGraph()
for i in range(999):
ss=spaceinput()
if not ss:
break
g.add_edge((ss[0],ss[1]),ss[2])
print(g.prim())
'''
d=g.dijkstra(1)
'''
'''
mint=10*9
for k in range(1,n+1):
dd=g.dijkstra(k)
v=max(dd.values())
if mint>v:
mint=v
print(mint)
''' |
s626351835 | p02364 | u510829608 | 1501308057 | Python | Python3 | py | Runtime Error | 0 | 0 | 1482 | import array
import collections
import heapq
AdjacentVertex = collections.namedtuple('AdjacentVertex', 'vertex cost')
INF = 2 ** 31 - 1
NO_VERTEX = -1
#Prim?????§??????0?????????????°???¨?????¨(minimum spanning tree????±???????)
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
#2????????????????????????????????\?????¨????????¨??????
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# ?????????????????\?????????????????\??£???????????????????????????
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq = True
return (pred, key)
max_v, max_e = map(int, input().split())
adjacent_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = map(int, input().split())
adjacent_list[s].add(AdjacentVertex(t,w))
adjacent_list[t].add(AdjacentVertex(s,w))
(_, key) = compute_mst_prim(max_v, adjacent_list)
print(sum(key.values())) |
s451716904 | p02364 | u510829608 | 1501308096 | Python | Python3 | py | Runtime Error | 0 | 0 | 1482 | import array
import collections
import heapq
AdjacentVertex = collections.namedtuple('AdjacentVertex', 'vertex cost')
INF = 2 ** 31 - 1
NO_VERTEX = -1
#Prim?????§??????0?????????????°???¨?????¨(minimum spanning tree????±???????)
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
#2????????????????????????????????\?????¨????????¨??????
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# ?????????????????\?????????????????\??£???????????????????????????
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq = True
return (pred, key)
max_v, max_e = map(int, input().split())
adjacent_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = map(int, input().split())
adjacent_list[s].add(AdjacentVertex(t,w))
adjacent_list[t].add(AdjacentVertex(s,w))
(_, key) = compute_mst_prim(max_v, adjacent_list)
print(sum(key.values())) |
s231016768 | p02364 | u510829608 | 1501308123 | Python | Python3 | py | Runtime Error | 0 | 0 | 1482 | import array
import collections
import heapq
AdjacentVertex = collections.namedtuple('AdjacentVertex', 'vertex cost')
INF = 2 ** 31 - 1
NO_VERTEX = -1
#Prim?????§??????0?????????????°???¨?????¨(minimum spanning tree????±???????)
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
#2????????????????????????????????\?????¨????????¨??????
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# ?????????????????\?????????????????\??£???????????????????????????
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq = True
return (pred, key)
max_v, max_e = map(int, input().split())
adjacent_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = map(int, input().split())
adjacent_list[s].add(AdjacentVertex(t,w))
adjacent_list[t].add(AdjacentVertex(s,w))
(_, key) = compute_mst_prim(max_v, adjacent_list)
print(sum(key.values())) |
s507452906 | p02364 | u510829608 | 1501308638 | Python | Python3 | py | Runtime Error | 0 | 0 | 2942 | import array
import collections
import heapq
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim?????§??????0?????????????°???¨?????¨????±???????
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
# ??????????????????????????????????????\?????¨????????¨??????
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# ????????????????????\?????????????????\??£???????????????????????????
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq[v] = True
return (pred, key)
max_v, max_e = map(int, input().split())
adjacency_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = map(int, input().split())
adjacency_list[s].add(AdjacentVertex(t, w))
adjacency_list[t].add(AdjacentVertex(s, w))
(_, key) = compute_mst_prim(max_v, adjacency_list)
print(sum(key.values()))import array
import collections
import heapq
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim?????§??????0?????????????°???¨?????¨????±???????
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
# ??????????????????????????????????????\?????¨????????¨??????
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# ????????????????????\?????????????????\??£???????????????????????????
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq[v] = True
return (pred, key)
max_v, max_e = map(int, input().split())
adjacency_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = map(int, input().split())
adjacency_list[s].add(AdjacentVertex(t, w))
adjacency_list[t].add(AdjacentVertex(s, w))
(_, key) = compute_mst_prim(max_v, adjacency_list)
print(sum(key.values())) |
s189812025 | p02364 | u881590806 | 1502609381 | Python | Python3 | py | Runtime Error | 30 | 7992 | 832 | from collections import defaultdict
INF = 9999999999999999999999999999
def spanning_tree(G):
n = len(G)
T = {}
added = set()
min_c = INF
for i in G:
for j in G[i]:
if G[i][j] < min_c:
min_c = G[i][j]
min_e = (i, j)
T[min_e] = min_c
added.add(min_e[0])
added.add(min_e[1])
while len(added) < n:
min_c = INF
for u in added:
for v in G[u]:
if v in added:
continue
if G[u][v] < min_c:
min_c = G[u][v]
min_e = (u, v)
T[min_e] = min_c
added.add(min_e[1])
return T
G = {}
n, m = [int(v) for v in input().strip().split(' ')]
for i in range(n):
G[i] = {}
for _ in range(m):
s, t, c = [int(v) for v in input().strip().split(' ')]
G[s][t] = c
G[t][s] = c
T = spanning_tree(G)
s = 0
for e in T:
s += T[e]
print(s) |
s767565344 | p02364 | u510829608 | 1504102928 | Python | Python3 | py | Runtime Error | 0 | 0 | 584 | mport heapq
from collections import defaultdict
INF = float('inf')
V, E = map(int, input().split())
Adj_list = defaultdict(set)
for i in range(E):
s, t, w = map(int, input().split())
Adj_list[s].add((t, w))
Adj_list[t].add((s, w))
def prim(x):
d = [INF] * x
d[0] = 0
hq = [(0,0)]
while hq:
val, u = heapq.heappop(hq)
if val > d[u]:
continue
for v, c in Adj_list[u]:
if d[v] > c:
d[v] = c
heapq.heappush(hq, (c, v))
return sum(d)
print(prim(V)) |
s050725167 | p02364 | u798803522 | 1507974416 | Python | Python3 | py | Runtime Error | 0 | 0 | 758 | from collections import defaultdict
import heapq
vertices, edges = (int(n) for n in input().split(" "))
conn = defaultdict(set)
weight = defaultdict(dict())
for i in range(edges):
v1, v2, w = (int(n) for n in input().split(" "))
conn[v1] |= {v2}
conn[v2] |= {v1}
weight[v1][v2] = w
weight[v2][v1] = w
queue = []
heapq.heapify(queue)
heapq.heappush(queue, [0,0])
went = set()
went_vertices = 0
answer_weight = 0
while went_vertices < vertices:
here_v, here_weight = heapq.heappop(queue)
if here_v in went:
continue
went |= {here_v}
for c in conn[here_v]:
if c not in went:
heapq.heappush(queue,[c, weight[here_v][c]])
answer_weight += here_weight
went_vertices += 1
print(answer_weight) |
s021693790 | p02365 | u797673668 | 1455910205 | Python | Python3 | py | Runtime Error | 30 | 7904 | 2089 | import heapq
nv, ne, r = map(int, input().split())
in_edges = {v: set() for v in range(nv)}
out_edges = {v: set() for v in range(nv)}
while ne:
s, t, w = map(int, input().split())
in_edges[t].add((w, s))
out_edges[s].add((w, t))
ne -= 1
def chu_liu_edmond(vertices):
global in_edges, out_edges, nv, r
total_cost = 0
prev_v = {v: None for v in vertices}
next_vs = {v: set() for v in vertices}
for t in vertices:
if t == r:
continue
min_in_w, min_in_s = min(in_edges[t])
total_cost += min_in_w
prev_v[t] = min_in_s
next_vs[min_in_s].add(t)
visited = {r}
queue = set(next_vs[r])
while queue:
t = queue.pop()
visited.add(t)
queue.update(next_vs[t])
cycles = []
for i in vertices:
if i in visited:
continue
cycle_vertices = set()
while i not in visited:
visited.add(i)
cycle_vertices.add(i)
i = prev_v[i]
# Branched single path from cycle
if i not in cycle_vertices:
continue
# Current cycle_vertices are not necessarily cycle (may be with branch from cycle)
cycle_vertices, j = {i}, i
while prev_v[j] != i:
cycle_vertices.add(j)
j = prev_v[j]
cycles.append(cycle_vertices)
if not cycles:
return total_cost
for cycle in cycles:
vertices.add(nv)
vertices -= cycle
for v in cycle:
for w, t in out_edges[v]:
if t not in cycle:
out_edges[nv].add((w, t))
in_edges[t].remove((w, v))
in_edges[t].add((w, nv))
for w, s in in_edges[v]:
if s not in cycle:
new_w = w - min(in_edges[v])[0]
in_edges[nv].add((new_w, s))
out_edges[s].remove((w, v))
out_edges[s].add((new_w, v))
nv += 1
return chu_liu_edmond(vertices)
print(chu_liu_edmond(set(range(nv)))) |
s476496161 | p02365 | u685815919 | 1475030188 | Python | Python | py | Runtime Error | 20 | 6488 | 1198 | def edmond(V, paths, root):
mins = [(10**18, -1)]*V
for s,t,w in paths:
mins[t] = min(mins[t], (w,s))
mins[r] = (-1, -1)
group = [0]*V
comp = [0]*V
cnt = 0
used = [0]*V
for v in xrange(V):
if not used[v]:
chain = []
cur = v
while not used[cur] and cur != -1:
chain.append(cur)
used[cur] = 1
cur = mins[cur][1]
if cur != -1:
cycle = 0
for e in chain:
group[e] = cnt
if e == cur:
cycle = 1
comp[cnt] = 1
if not cycle:
cnt += 1
if cycle:
cnt += 1
else:
for e in chain:
group[e] = cnt
cnt += 1
if cnt == V:
return sum(map(lambda x:x[0], mins)) + 1
res = sum(mins[v][0] for v in xrange(V) if v != r and comp[group[v]])
n_es = []
for s,t,w in paths:
gs = group[s]
gt = group[t]
if gs == gt:
continue
if comp[gt]:
n_es.append((gs, gt, w-mins[y][0]))
else:
n_es.append((gs, gt, w))
return res + emond(cnt, n_es, group[r])
V,E,r = map(int, raw_input().split())
paths = [map(int, raw_input().split()) for _ in xrange(E)]
print edmond(V, paths, r) |
s217883813 | p02365 | u072053884 | 1484492190 | Python | Python3 | py | Runtime Error | 30 | 7860 | 1750 | # Acceptance of input
import sys
file_input = sys.stdin
v_num, e_num, r = map(int, file_input.readline().split())
G = [[] for i in range(v_num)]
import heapq
for line in file_input:
s, t, w = map(int, line.split())
if t != r:
heapq.heappush(G[t], [w, s, t])
# Edmonds' algorithm
def find_cycle(incoming_edges, root):
in_tree = [False] * v_num
in_tree[root] = True
for e in incoming_edges[:root] + incoming_edges[root + 1:]:
S = []
S.append(e[2])
while True:
p = incoming_edges[S[-1]][1]
if in_tree[p]:
while S:
in_tree[S.pop()] = True
break
elif p in S:
return S[S.index(p):] # return nodes in a cycle
else:
S.append(p)
return None
def contract_cycle(digraph, cycle_node):
for edges in digraph:
min_weight = edges[0][0]
for e in edges:
e[0] -= min_weight
contracted_edges = []
for n in cycle_node:
edge_set_in_cycle = digraph[n]
heapq.heappop(edge_set_in_cycle)
for e in edge_set_in_cycle:
heapq.heappush(contracted_edges, e)
for n in cycle_node:
digraph[n] = contracted_edges
def edmonds_branching(digraph, root, weight):
min_incoming_edges = [None] * v_num
for edges in digraph[:root] + digraph[root + 1:]:
min_edge = edges[0]
min_incoming_edges[min_edge[2]] = min_edge
weight += min_edge[0]
C = find_cycle(min_incoming_edges, root)
if not C:
return weight
else:
contract_cycle(digraph, C)
return edmonds_branching(digraph, root, weight)
# output
print(edmonds_branching(G, r, 0)) |
s747186568 | p02365 | u035108350 | 1500340750 | Python | Python3 | py | Runtime Error | 0 | 0 | 4215 | class Node:
def __init__(self):
pass
class Edge:
def __init__(self,edge,cost=1):
self.node_from=edge[0]
self.node_to=edge[1]
self.cost=cost
def add_node(self,node):
self.nodes.append(node)
class myGraph:
def __init__(self):
self.adj={}
self.nodes={}
def add_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
# add the edge
self.adj[u][v] = cost
self.adj[v][u] = cost
def add_directed_edge(self,edge,cost):
if len(edge)==1:
edge=list(edge)
u,v=edge[0],edge[1]
if u not in self.nodes:
self.adj[u] = {}
self.nodes[u] = {}
if v not in self.nodes:
self.adj[v] = {}
self.nodes[v] = {}
self.adj[u][v] = cost
def get_edges_from(self,node):
return [(self.adj[node][nn],node,nn) for nn in self.adj[node]]
def makeEdgeobj(self):
edges=[]
for sn in self.nodes:
for e in self.get_edges_from(sn):
edges.append(Edge([e[1],e[2]],e[0]))
return edges
def _add(self,edges,add_edges):
for e in add_edges:
hq.heappush(edges,e)
return edges
def bermn_ford(self,start,init=0):
nodes=self.nodes
dists={}
for n in nodes:
dists[n]=float("inf")
dists[start]=init
edges=self.makeEdgeobj()
for i in range(len(nodes)):
update=False
for k in range(len(edges)):
e=edges[k]
if dists[e.node_from]!=float("inf") and dists[e.node_to]>dists[e.node_from]+e.cost:
dists[e.node_to]=dists[e.node_from]+e.cost
update=True
if i==len(nodes)-1:
return False
if not update:
break
return dists
def dijkstra(self,start, goal=None):
import heapq
'''
get minimum cost
'''
N = len(self.adj) # ??°????????????????????°
#dist = [float('inf') for i in range(N)] # ?§????????????????????????§??????????????¢???????´???????
dist = {k:float('inf') for k in self.nodes}
#prev = [float('inf') for i in range(N)]
dist[start] = 0
visited = []
koho=[]
heapq.heappush(koho,(0,start))
vtx=list(self.nodes)
vtx.remove(start)
while len(koho)!=0:
d,mini=heapq.heappop(koho)
if dist[mini]<d:
continue
for k in list(self.adj[mini]):
cost=self.adj[mini][k]
if cost != float('inf') and dist[k]>dist[mini]+cost:# and not(k in visited):
dist[k]=dist[mini]+cost
heapq.heappush(koho,(dist[k],k))
#prev[k]=mini
return dist
def prim(self):
import heapq
nodes=list(self.nodes.keys())
N=len(nodes)
X=[nodes[0]]
unused=[]
for u in self.adj[X[0]]:
heapq.heappush(unused,(u,self.adj[X[0]][u]))
total_cost=0
while True:
v,cost=heapq.heappop(unused)
X.append(v)
total_cost+=cost
if len(X)==N:
break
for u in self.adj[v]:
heapq.heappush(unused,(u,self.adj[v][u]))
return total_cost
def spaceinput():
s=input()
if len(s)==0:
return False
return list(map(int,s.split(" ")))
if __name__=="__main__":
a=spaceinput()
g=myGraph()
for i in range(999):
ss=spaceinput()
if not ss:
break
g.add_edge((ss[0],ss[1]),ss[2])
print(g.prim())
'''
d=g.dijkstra(1)
'''
'''
mint=10*9
for k in range(1,n+1):
dd=g.dijkstra(k)
v=max(dd.values())
if mint>v:
mint=v
print(mint)
''' |
s070147456 | p02366 | u967553879 | 1556715855 | Python | Python3 | py | Runtime Error | 30 | 7140 | 1313 | from collections import deque
def dfs(current, prev):
global time
# node currentを訪問した直後の処理
ord[current] = time
low[current] = time
time += 1
color[current] = BLACK
for next in G[current]:
if color[next] == WHITE:
# node currentからnode nextへ訪問する直前の処理
parent[next] = current
dfs(next, current)
# node nextの探索が終了した直後の処理
low[current] = min(low[current], low[next])
elif next != prev:
# edge current --> next がback-edgeの場合の処理
low[current] = min(low[current], ord[next])
def art_points():
global time
time = 1
dfs(0, -1) # 0をrootとしてlowの計算
np = 0
for i in range(1, v):
p = parent[i]
if p == 0:
np += 1
elif ord[p] <= low[i]:
ap.add(p)
if np > 1:
ap.add(0)
G = {}
v, n = map(int, input().split())
for i in range(0, v):
G[i] = []
for i in range(n):
s, t = map(int, input().split())
G[s].append(t)
G[t].append(s)
WHITE = 0
BLACK = 2
color = [WHITE] * (v)
parent = [0] * (v)
ord = [0] * (v)
low = [0] * (v)
parent = [0] * (v)
ap = set([])
art_points()
if ap:
print(*sorted(ap), sep='\n')
|
s207467058 | p02366 | u567380442 | 1428131860 | Python | Python3 | py | Runtime Error | 50 | 7544 | 1368 | def dfs(u, prev, visited, lowest, parent, prenum):
# ????????? u ????¨????????????´????????????
visited |= {u}
prenum[u] = len(visited)
lowest[u] = len(visited)
for v in g[u]:
if v not in visited:
# ????????? u ??????????????? v ????¨????????????´????????????
parent[v] = u
dfs(v, u, visited, lowest, parent, prenum)
# ????????? v ?????¢?´¢?????????????????´????????????
lowest[u] = min(lowest[u], lowest[v])
elif v != prev:
# ??¨?????? u --> v ??? Back-edge ?????´????????????
lowest[u] = min(lowest[u], prenum[v])
# ????????? u ?????¢?´¢?????????????????´????????????
from sys import stdin
readline = stdin.readline
v, e = map(int, readline().split())
from collections import defaultdict
g = defaultdict(list)
for _ in range(e):
s, t = map(int, readline().split())
g[s].append(t)
g[t].append(s)
visited = set()
lowest = [None] * v
parent = [None] * v
prenum = [None] * v
root = 0
# lowest ????¨????
dfs(root, -1, visited, lowest, parent, prenum)
child = defaultdict(list)
for i in range(v):
if parent[i] is not None:
child[parent[i]].append(i)
if 2 <= len(child[root]):
print(root)
for i in range(1, v):
if child[i] and any(prenum[i] <= lowest[j] for j in child[i]):
print(i) |
s949682410 | p02366 | u567380442 | 1428139037 | Python | Python3 | py | Runtime Error | 0 | 0 | 1113 | from sys import stdin
readline = stdin.readline
v, e = map(int, readline().split())
from collections import defaultdict
g = defaultdict(list)
for _ in range(e):
s, t = map(int, readline().split())
g[s].append(t)
g[t].append(s)
visited = set()
lowest = [None] * v
parent = [None] * v
prenum = [None] * v
child = defaultdict(list)
root = 0
# dfs??§tree?????????
que = deque([root])
while que:
u = que.popleft()
visited |= {u}
prenum[u] = lowest[u] = len(visited)
for vi in g[u]:
if vi not in visited:
parent[vi] = u
que.append(vi)
for i in range(v):
if parent[i] is not None:
child[parent[i]].append(i)
leaf = [i for i in range(v) if not child[i]]
for li in leaf:
while li is not None:
candidate = [prenum[li]] + [prenum[i] for i in g[li] if i != parent[li]] + [lowest[i] for i in child[i]]
lowest[li] = min(candidate)
li = parent[li]
if 2 <= len(child[root]):
print(root)
for i in range(1, v):
if child[i] and any(prenum[i] <= lowest[j] for j in child[i]):
print(i) |
s885290037 | p02366 | u567380442 | 1428140177 | Python | Python3 | py | Runtime Error | 0 | 0 | 1103 | from sys import stdin
readline = stdin.readline
v, e = map(int, readline().split())
from collections import defaultdict
g = defaultdict(list)
for _ in range(e):
s, t = map(int, readline().split())
g[s].append(t)
g[t].append(s)
visited = set()
lowest = [None] * v
parent = [None] * v
prenum = [None] * v
child = defaultdict(list)
root = 0
# dfs??§tree?????????
stack = [(root, None)]
while stack:
u, prev = stack.pop()
if u not in visited:
parent[u] = prev
if prev is not None:
child[prev].append(u)
visited |= {u}
prenum[u] = lowest[u] = len(visited)
stack.extend([(v, u) for v in g[u] if v not in visited])
leaf = [i for i in range(v) if not child[i]]
for li in leaf:
while li is not None:
candidate = [prenum[li]] + [prenum[i] for i in g[li] if i != parent[li]] + [lowest[i] for i in child[i]]
lowest[li] = min(candidate)
li = parent[li]
if 2 <= len(child[root]):
print(root)
for i in range(1, v):
if child[i] and any(prenum[i] <= lowest[j] for j in child[i]):
print(i) |
s036233960 | p02366 | u106851363 | 1444544678 | Python | Python3 | py | Runtime Error | 0 | 0 | 3268 | __author__ = 'zhewang711'
class Graph:
def __init__(self):
self.vertices = 0
self.outgoing = {}
self.root_cnt = 0
# self.incoming = {}
self.result = []
def insert_vertice(self):
self.vertices += 1
self.outgoing[self.vertices - 1] = []
# self.incoming[self.vertices - 1] = {}
def insert_edge(self, s, d):
if s >= self.vertices or d >= self.vertices:
raise ValueError('edge cannot be inserted because vertex do not exist')
else:
self.outgoing[s].append(d)
self.outgoing[d].append(s)
def get_input(self):
s = input()
V, E = int(s.split()[0]), int(s.split()[1])
self.discovery = [None for i in range(V)]
self.clock = 0
self.explored = [False for i in range(V)]
self.father = [None for i in range(V)]
self.backing = [None for i in range(V)]
self.sub_have_backing = [None for i in range(V)]
for i in range(V):
self.insert_vertice()
for i in range(E):
s = input()
self.insert_edge(int(s.split()[0]), int(s.split()[1]))
def read_input(self, filename):
f = open(filename, 'r')
cnt = 0
for line in f:
if cnt == 0:
cnt += 1
V, E = int(line.split()[0]), int(line.split()[1])
self.discovery = [None for i in range(V)]
self.clock = 0
self.explored = [False for i in range(V)]
self.father = [None for i in range(V)]
self.backing = [None for i in range(V)]
self.sub_have_backing = [None for i in range(V)]
for i in range(V):
self.insert_vertice()
else:
self.insert_edge(int(line.split()[0]), int(line.split()[1]))
def DFS(self, root, father):
self.explored[root] = True
self.discovery[root] = self.clock
self.backing[root] = self.clock
self.clock += 1
root_backing = float('inf')
for ver in self.outgoing[root]:
if not self.explored[ver]:
ver_backing = self.DFS(ver, root)
self.backing[root] = min(self.backing[root], self.backing[ver], ver_backing)
else:
if ver != father:
root_backing = min(self.backing[ver], root_backing)
return root_backing
def _critical_points(self, root):
self.explored[root] = True
self.discovery[root] = self.clock
self.clock += 1
is_leaf = True
for ver in self.outgoing[root]:
if not self.explored[ver]:
if root == 0:
self.root_cnt += 1
is_leaf = False
self._critical_points(ver)
if not is_leaf:
if self.backing[root] >= self.discovery[root] and root != 0:
self.result.append(root)
g = Graph()
#g.get_input()
g.read_input('1.txt')
g.DFS(0, None)
g.clock = 0
g.discovery = [None for i in range(g.vertices)]
g.explored = [False for i in range(g.vertices)]
g._critical_points(0)
if g.root_cnt >= 2:
g.result.append(0)
l = sorted(g.result)
for i in l:
print(i) |
s299166673 | p02366 | u106851363 | 1444551595 | Python | Python3 | py | Runtime Error | 0 | 0 | 3221 | __author__ = 'zhewang711'
class Graph:
def __init__(self):
self.vertices = 0
self.outgoing = {}
self.root_cnt = 0
# self.incoming = {}
self.result = []
def insert_vertice(self):
self.vertices += 1
self.outgoing[self.vertices - 1] = []
# self.incoming[self.vertices - 1] = {}
def insert_edge(self, s, d):
if s >= self.vertices or d >= self.vertices:
raise ValueError('edge cannot be inserted because vertex do not exist')
else:
self.outgoing[s].append(d)
self.outgoing[d].append(s)
def get_input(self):
s = input()
V, E = int(s.split()[0]), int(s.split()[1])
self.discovery = [None for i in range(V)]
self.clock = 0
self.explored = [False for i in range(V)]
self.father = [None for i in range(V)]
self.backing = [None for i in range(V)]
self.sub_have_backing = [None for i in range(V)]
for i in range(V):
self.insert_vertice()
for i in range(E):
s = input()
self.insert_edge(int(s.split()[0]), int(s.split()[1]))
def read_input(self, filename):
f = open(filename, 'r')
cnt = 0
for line in f:
if cnt == 0:
cnt += 1
V, E = int(line.split()[0]), int(line.split()[1])
self.discovery = [None for i in range(V)]
self.clock = 0
self.explored = [False for i in range(V)]
self.father = [None for i in range(V)]
self.backing = [None for i in range(V)]
self.sub_have_backing = [False for i in range(V)]
self.is_leaf = [None for i in range(V)]
for i in range(V):
self.insert_vertice()
else:
self.insert_edge(int(line.split()[0]), int(line.split()[1]))
def DFS(self, root):
self.explored[root] = True
self.discovery[root] = self.clock
self.backing[root] = self.clock
self.clock += 1
self.is_leaf[root] = True
for ver in self.outgoing[root]:
if not self.explored[ver]:
self.is_leaf[root] = False
self.DFS(ver)
self.backing[root] = min(self.backing[root], self.backing[ver])
else:
self.backing[root] = min(self.backing[root], self.discovery[ver])
def _critical_points(self, root):
self.explored[root] = True
self.discovery[root] = self.clock
self.clock += 1
for ver in self.outgoing[root]:
if not self.explored[ver]:
if root == 0:
self.root_cnt += 1
if self.backing[ver] >= self.discovery[root] and root !=0 and not self.is_leaf[root]:
self.result.append(root)
self._critical_points(ver)
g = Graph()
g.get_input()
#g.read_input('1.txt')
g.DFS(0)
g.clock = 0
g.discovery = [None for i in range(g.vertices)]
g.explored = [False for i in range(g.vertices)]
g._critical_points(0)
if g.root_cnt >= 2:
g.result.append(0)
l = sorted(g.result)
for i in l:
print(i) |
s562581919 | p02366 | u106851363 | 1444551993 | Python | Python3 | py | Runtime Error | 70 | 8752 | 3266 | __author__ = 'zhewang711'
class Graph:
def __init__(self):
self.vertices = 0
self.outgoing = {}
self.root_cnt = 0
# self.incoming = {}
self.result = set()
def insert_vertice(self):
self.vertices += 1
self.outgoing[self.vertices - 1] = []
# self.incoming[self.vertices - 1] = {}
def insert_edge(self, s, d):
if s >= self.vertices or d >= self.vertices:
raise ValueError('edge cannot be inserted because vertex do not exist')
else:
self.outgoing[s].append(d)
self.outgoing[d].append(s)
def get_input(self):
s = input()
V, E = int(s.split()[0]), int(s.split()[1])
self.discovery = [None for i in range(V)]
self.clock = 0
self.explored = [False for i in range(V)]
self.father = [None for i in range(V)]
self.backing = [None for i in range(V)]
self.sub_have_backing = [None for i in range(V)]
self.is_leaf = [None for i in range(V)]
for i in range(V):
self.insert_vertice()
for i in range(E):
s = input()
self.insert_edge(int(s.split()[0]), int(s.split()[1]))
def read_input(self, filename):
f = open(filename, 'r')
cnt = 0
for line in f:
if cnt == 0:
cnt += 1
V, E = int(line.split()[0]), int(line.split()[1])
self.discovery = [None for i in range(V)]
self.clock = 0
self.explored = [False for i in range(V)]
self.father = [None for i in range(V)]
self.backing = [None for i in range(V)]
self.sub_have_backing = [False for i in range(V)]
self.is_leaf = [None for i in range(V)]
for i in range(V):
self.insert_vertice()
else:
self.insert_edge(int(line.split()[0]), int(line.split()[1]))
def DFS(self, root):
self.explored[root] = True
self.discovery[root] = self.clock
self.backing[root] = self.clock
self.clock += 1
self.is_leaf[root] = True
for ver in self.outgoing[root]:
if not self.explored[ver]:
self.is_leaf[root] = False
self.DFS(ver)
self.backing[root] = min(self.backing[root], self.backing[ver])
else:
self.backing[root] = min(self.backing[root], self.discovery[ver])
def _critical_points(self, root):
self.explored[root] = True
self.discovery[root] = self.clock
self.clock += 1
for ver in self.outgoing[root]:
if not self.explored[ver]:
if root == 0:
self.root_cnt += 1
if self.backing[ver] >= self.discovery[root] and root !=0 and not self.is_leaf[root]:
self.result.add(root)
self._critical_points(ver)
g = Graph()
g.get_input()
#g.read_input('1.txt')
g.DFS(0)
g.clock = 0
g.discovery = [None for i in range(g.vertices)]
g.explored = [False for i in range(g.vertices)]
g._critical_points(0)
if g.root_cnt >= 2:
g.result.add(0)
l = sorted(g.result)
for i in l:
print(i) |
s774779117 | p02366 | u797673668 | 1461573976 | Python | Python3 | py | Runtime Error | 50 | 8964 | 898 | n, m = map(int, input().split())
edges = [set() for _ in range(n)]
for _ in range(m):
s, t = map(int, input().split())
edges[s].add(t)
edges[t].add(s)
prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0
def dfs(cur, prev):
global counter
prenum[cur] = lowest[cur] = counter
counter += 1
for edge in edges[cur]:
if prenum[edge] is not None:
if edge != prev:
lowest[cur] = min(lowest[cur], prenum[edge])
continue
parent[edge] = cur
dfs(edge, cur)
lowest[cur] = min(lowest[cur], lowest[edge])
dfs(0, 1)
ap = [False] * n
r = 0
for _ in filter(lambda x: x == 0, parent):
r += 1
if r > 1:
ap[0] = True
break
for i in range(1, n):
p = parent[i]
if p and prenum[p] <= lowest[i]:
ap[p] = True
for i, e in enumerate(ap):
if e: print(i) |
s463524665 | p02366 | u894114233 | 1461738300 | Python | Python | py | Runtime Error | 0 | 0 | 536 | def dfs(s,p):
global V,color
color[s]=1
for i in V[s] :
if color[i]==0 and i!=p:
dfs(i,p)
color[s]=2
def AP():
global V,ap,n,color
for i in xrange(n):
color=[0]*n
dfs(V[i][0],i)
color[i]=2
print color
if color!=[2]*n:
ap.append(i)
n,e=map(int,raw_input().split())
ap=[]
V=[[] for i in xrange(n)]
for i in xrange(e):
s,t=map(int,raw_input().split())
V[s].append(t)
V[t].append(s)
AP()
for i in xrange(len(ap)):
print(ap[i]) |
s534227465 | p02366 | u894114233 | 1461738330 | Python | Python | py | Runtime Error | 0 | 0 | 516 | def dfs(s,p):
global V,color
color[s]=1
for i in V[s] :
if color[i]==0 and i!=p:
dfs(i,p)
color[s]=2
def AP():
global V,ap,n,color
for i in xrange(n):
color=[0]*n
dfs(V[i][0],i)
color[i]=2
if color!=[2]*n:
ap.append(i)
n,e=map(int,raw_input().split())
ap=[]
V=[[] for i in xrange(n)]
for i in xrange(e):
s,t=map(int,raw_input().split())
V[s].append(t)
V[t].append(s)
AP()
for i in xrange(len(ap)):
print(ap[i]) |
s590812376 | p02366 | u894114233 | 1461738980 | Python | Python | py | Runtime Error | 750 | 7104 | 595 | def dfs(s,p,color):
color[s]=1
for i in V[s] :
if color[i]==0 and i!=p:
dfs(i,p,color)
color[s]=2
def AP():
for i in xrange(n):
color=[0]*n
dfs(V[i][0],i,color)
color[i]=2
if color!=[2]*n:
ap.append(i)
n,e=map(int,raw_input().split())
ap=[]
V=[[] for i in xrange(n)]
for i in xrange(e):
s,t=map(int,raw_input().split())
V[s].append(t)
V[t].append(s)
if e==0:
if n>=3:
for i in xrange(n):
print(i)
else:
pass
else:
AP()
for i in xrange(len(ap)):
print(ap[i]) |
s802953858 | p02366 | u894114233 | 1461739837 | Python | Python | py | Runtime Error | 30 | 6464 | 729 | import sys
sys.setrecursionlimit(10*6)
def dfs(s,p,color):
color[s]=1
for i in V[s] :
if color[i]==0 and i!=p:
dfs(i,p,color)
color[s]=2
def AP():
for i in xrange(vn):
if V[i]!=[]:
color=[0]*vn
dfs(V[i][0],i,color)
color[i]=2
if color!=[2]*vn:
ap.append(i)
else:
ap.append(i)
vn,e=map(int,raw_input().split())
ap=[]
V=[[] for i in xrange(vn)]
for i in xrange(e):
s,t=map(int,raw_input().split())
V[s].append(t)
V[t].append(s)
if e==0:
if vn>=3:
for i in xrange(vn):
print(i)
else:
pass
else:
AP()
for i in xrange(len(ap)):
print(ap[i]) |
s649288766 | p02366 | u022407960 | 1480319923 | Python | Python3 | py | Runtime Error | 30 | 8756 | 1808 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
from sys import stdin
UNVISITED, VISITED_IN_STACK, POPPED_OUT = 0, 1, 2
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(current, prev):
global timer
pre_v[current] = lowest_v[current] = timer
timer += 1
color[current] = VISITED_IN_STACK
for adj in adj_table[current]:
if color[adj] is UNVISITED:
parent_v[adj] = current
graph_dfs(adj, current)
lowest_v[current] = min(lowest_v[current], lowest_v[adj])
elif adj is not prev:
lowest_v[current] = min(lowest_v[current], pre_v[adj])
return None
def art_points():
graph_dfs(0, -1)
v_count = 0
for j in range(1, vertices):
parent = parent_v[j]
if parent == init_vertex_index:
v_count += 1
elif pre_v[parent] <= lowest_v[j]:
ans.add(parent)
if v_count > 1:
ans.add(init_vertex_index)
return ans
if __name__ == '__main__':
_input = stdin.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
pre_v, parent_v, lowest_v = ([-1] * vertices for _ in range(3))
init_adj_table = tuple([] for _ in range(vertices))
timer = 1
# root
init_vertex_index = 0
ans = set()
color = [UNVISITED] * vertices
adj_table = generate_adj_table(v_info)
res = art_points()
if not res:
pass
else:
# print(*sorted(art_points()), sep='\n')
print(*sorted(res), sep='\n') |
s963184012 | p02366 | u022407960 | 1480320046 | Python | Python3 | py | Runtime Error | 50 | 8800 | 1808 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
from sys import stdin
UNVISITED, VISITED_IN_STACK, POPPED_OUT = 0, 1, 2
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(current, prev):
global timer
pre_v[current] = lowest_v[current] = timer
timer += 1
color[current] = VISITED_IN_STACK
for adj in adj_table[current]:
if color[adj] is UNVISITED:
parent_v[adj] = current
graph_dfs(adj, current)
lowest_v[current] = min(lowest_v[current], lowest_v[adj])
elif adj is not prev:
lowest_v[current] = min(lowest_v[current], pre_v[adj])
return None
def art_points():
graph_dfs(0, -1)
v_count = 0
for j in range(1, vertices):
parent = parent_v[j]
if parent == init_vertex_index:
v_count += 1
elif pre_v[parent] <= lowest_v[j]:
ans.add(parent)
if v_count > 1:
ans.add(init_vertex_index)
return ans
if __name__ == '__main__':
_input = stdin.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
pre_v, parent_v, lowest_v = ([-1] * vertices for _ in range(3))
init_adj_table = tuple([] for _ in range(vertices))
timer = 1
# root
init_vertex_index = 0
ans = set()
color = [UNVISITED] * vertices
adj_table = generate_adj_table(v_info)
res = art_points()
if not res:
pass
else:
# print(*sorted(art_points()), sep='\n')
print(*sorted(res), sep='\n') |
s572881673 | p02366 | u022407960 | 1480321663 | Python | Python3 | py | Runtime Error | 0 | 0 | 1922 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
from sys import stdin
UNVISITED, VISITED_IN_STACK, POPPED_OUT = 0, 1, 2
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(current, prev):
global timer
pre_v[current] = lowest_v[current] = timer
timer += 1
color[current] = VISITED_IN_STACK
for adj in adj_table[current]:
if color[adj] is UNVISITED:
parent_v[adj] = current
# recursive dfs
graph_dfs(adj, current)
lowest_v[current] = min(lowest_v[current], lowest_v[adj])
elif adj is not prev:
lowest_v[current] = min(lowest_v[current], pre_v[adj])
return None
def art_points():
graph_dfs(0, -1)
v_count = 0
for j in range(1, vertices):
parent = parent_v[j]
if parent == init_vertex_index:
v_count += 1
elif pre_v[parent] <= lowest_v[j]:
ans.add(parent)
if v_count > 1:
ans.add(init_vertex_index)
return ans
if __name__ == '__main__':
# _input = stdin.readlines()
_in = open('test.txt', 'rt')
_input = _in.readlines()
# raise SystemExit
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
pre_v, parent_v, lowest_v = ([0] * vertices for _ in range(3))
init_adj_table = tuple([] for _ in range(vertices))
timer = 1
# root
init_vertex_index = 0
ans = set()
color = [UNVISITED] * vertices
adj_table = generate_adj_table(v_info)
res = art_points()
if not res:
pass
else:
# print(*sorted(art_points()), sep='\n')
print(*sorted(res), sep='\n') |
s864056130 | p02366 | u022407960 | 1480321700 | Python | Python3 | py | Runtime Error | 20 | 8792 | 1858 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
from sys import stdin
UNVISITED, VISITED_IN_STACK, POPPED_OUT = 0, 1, 2
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(current, prev):
global timer
pre_v[current] = lowest_v[current] = timer
timer += 1
color[current] = VISITED_IN_STACK
for adj in adj_table[current]:
if color[adj] is UNVISITED:
parent_v[adj] = current
# recursive dfs
graph_dfs(adj, current)
lowest_v[current] = min(lowest_v[current], lowest_v[adj])
elif adj is not prev:
lowest_v[current] = min(lowest_v[current], pre_v[adj])
return None
def art_points():
graph_dfs(0, -1)
v_count = 0
for j in range(1, vertices):
parent = parent_v[j]
if parent == init_vertex_index:
v_count += 1
elif pre_v[parent] <= lowest_v[j]:
ans.add(parent)
if v_count > 1:
ans.add(init_vertex_index)
return ans
if __name__ == '__main__':
_input = stdin.readlines()
# raise SystemExit
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
pre_v, parent_v, lowest_v = ([0] * vertices for _ in range(3))
init_adj_table = tuple([] for _ in range(vertices))
timer = 1
# root
init_vertex_index = 0
ans = set()
color = [UNVISITED] * vertices
adj_table = generate_adj_table(v_info)
res = art_points()
if not res:
pass
else:
# print(*sorted(art_points()), sep='\n')
print(*sorted(res), sep='\n') |
s591469860 | p02366 | u022407960 | 1480324495 | Python | Python3 | py | Runtime Error | 0 | 0 | 1900 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
import sys
sys.setrecursionlimit(int(3e6))
UNVISITED, VISITED_IN_STACK, POPPED_OUT = 0, 1, 2
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(current, prev):
global timer
pre_v[current] = lowest_v[current] = timer
timer += 1
color[current] = VISITED_IN_STACK
for adj in adj_table[current]:
if color[adj] is UNVISITED:
parent_v[adj] = current
# recursive dfs
graph_dfs(adj, current)
lowest_v[current] = min(lowest_v[current], lowest_v[adj])
elif adj is not prev:
lowest_v[current] = min(lowest_v[current], pre_v[adj])
return None
def art_points():
graph_dfs(dfs_root, -1)
np = 0
for v in range(1, vertices):
parent = parent_v[v]
if parent is dfs_root:
np += 1
elif pre_v[parent] <= lowest_v[v]:
ans.add(parent)
if np > 1:
ans.add(dfs_root)
return ans
if __name__ == '__main__':
# _input = sys.stdin.readlines()
with open('test.txt', 'rt') as _in:
_input = _in.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
pre_v, parent_v, lowest_v = ([0] * vertices for _ in range(3))
init_adj_table = tuple([] for _ in range(vertices))
timer = 1
# root
dfs_root = 0
ans = set()
color = [UNVISITED] * vertices
adj_table = generate_adj_table(v_info)
res = art_points()
if not res:
pass
else:
# print(*sorted(art_points()), sep='\n')
print(*sorted(res), sep='\n') |
s807469391 | p02366 | u022407960 | 1481632984 | Python | Python3 | py | Runtime Error | 40 | 10452 | 1551 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
import sys
sys.setrecursionlimit(int(1e4))
def dfs_Tarjan(current):
global timer
children = 0
visited[current] = True
disc[current] = low[current] = timer
timer += 1
for adj in adj_table[current]:
if not visited[adj]:
parent[adj] = current
children += 1
dfs_Tarjan(adj)
low[current] = min(low[current], low[adj])
# current vertex is the root of DFS tree
if parent[current] == -1 and children > 1:
art_set.add(current)
elif parent[current] != -1 and low[adj] >= disc[current]:
art_set.add(current)
elif adj != parent[current]:
low[current] = min(low[current], disc[adj])
return None
def dfs_init():
for v in range(v_num):
if not visited[v]:
dfs_Tarjan(v)
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
v_num, e_num = map(int, _input[0].split())
edges = map(lambda x: x.split(), _input[1:])
adj_table = tuple([] for _ in range(v_num))
for edge in edges:
source, target = map(int, edge)
adj_table[source].append(target)
adj_table[target].append(source)
timer = 0
art_set = set()
parent = [-1] * v_num
visited = [False] * v_num
disc, low = ([float('inf')] * v_num for _ in range(2))
dfs_init()
if art_set:
print(*sorted(art_set), sep='\n') |
s265991570 | p02366 | u400336986 | 1487447782 | Python | Python3 | py | Runtime Error | 0 | 0 | 809 | def dfs(v, tm):
dts[v] = est[v] = tm
child = 0
for i in range(nv):
if adj[v][i]:
if parents[i] is None:
child += 1
parents[i] = v
dfs(i, tm + 1)
est[v] = min(est[v], est[i])
if parents[v] is None and child > 1: aps[v] = True
if parents[v] is not None and est[i] >= dts[v]: aps[v] = True
elif parents[v] != i:
est[v] = min(est[v], dts[i])
nv, ne = map(int, input().split(' '))
adj = [[False] * nv for _ in range(nv)]
est = [float('inf')] * nv
parents = [None] * nv
aps = [False] * nv
dts = [0] * nv
for _ in range(ne):
s, t = map(int, input().split(' '))
adj[s][t] = adj[t][s] = True
dfs(0, 0)
[print(i) if aps[i] else _ for i in range(nv)] |
s024721865 | p02366 | u400336986 | 1487447981 | Python | Python3 | py | Runtime Error | 160 | 16596 | 856 | def dfs(v, tm):
visited[v] = True
dts[v] = est[v] = tm
child = 0
for i in range(nv):
if adj[v][i]:
if not visited[i]:
child += 1
parents[i] = v
dfs(i, tm + 1)
est[v] = min(est[v], est[i])
if parents[v] is None and child > 1: aps[v] = True
if parents[v] is not None and est[i] >= dts[v]: aps[v] = True
elif parents[v] != i:
est[v] = min(est[v], dts[i])
nv, ne = map(int, input().split(' '))
adj = [[False] * nv for _ in range(nv)]
est = [float('inf')] * nv
visited = [False] * nv
parents = [None] * nv
aps = [False] * nv
dts = [0] * nv
for _ in range(ne):
s, t = map(int, input().split(' '))
adj[s][t] = adj[t][s] = True
dfs(0, 0)
for i in range(nv):
if aps[i]:
print(i) |
s227607133 | p02366 | u881590806 | 1490960152 | Python | Python | py | Runtime Error | 0 | 0 | 1221 | def dfs(G,s,p,prenum,T,parents):
if len(G[s]) == 0: return p
T[s] = set()
prenum[s] = p
for c in G[s]:
if c in T: continue
p = dfs(G,c,p+1,prenum,T,parents)
T[s].add(c)
T[c].add(s)
parents[c] = s
return p
def find(G):
points = []
lowest = {}
prenum = {}
parents = {0:None}
T = {}
dfs(G,0,1,prenum,T,parents)
for s in G:
lowest[s] = prenum[s]
for t in G[s]:
if not t in T[s]:
if lowest[s] > prenum[t]:
lowest[s] = prenum[t]
for s in T:
for t in T[s]:
if t==parents[s]: continue
if lowest[s] > lowest[t]:
lowest[s] = lowest[t]
for s in T:
p = parents[s]
if p is None:
if len(T[s])-1>1: points.append(s)
else:
if parents[p] is None: continue
if prenum[p] < lowest[s]:
points.append(p)
return points
n,m = map(int,raw_input().split(' '))
G = {}
for i in range(n):
G[i] = set()
for i in range(m):
s,t = map(int,raw_input().split(' '))
G[s].add(t)
G[t].add(s)
points = find(G)
for p in sorted(points):
print p |
s584254139 | p02366 | u881590806 | 1490960203 | Python | Python | py | Runtime Error | 0 | 0 | 1218 | def dfs(G,s,p,prenum,T,parents):
if len(G[s]) == 0: return p
T[s] = set()
prenum[s] = p
for c in G[s]:
if c in T: continue
p = dfs(G,c,p+1,prenum,T,parents)
T[s].add(c)
T[c].add(s)
parents[c] = s
return p
def find(G):
points = []
lowest = {}
prenum = {}
parents = {0:None}
T = {}
dfs(G,0,1,prenum,T,parents)
for s in G:
lowest[s] = prenum[s]
for t in G[s]:
if not t in T[s]:
if lowest[s] > prenum[t]:
lowest[s] = prenum[t]
for s in T:
for t in T[s]:
if t==parents[s]: continue
if lowest[s] > lowest[t]:
lowest[s] = lowest[t]
for s in T:
p = parents[s]
if p is None:
if len(T[s])-1>1: points.append(s)
else:
if parents[p] is None: continue
if prenum[p] < lowest[s]:
points.append(p)
return points
n,m = map(int,raw_input().split(' '))
G = {}
for i in range(n):
G[i] = set()
for i in range(m):
s,t = map(int,raw_input().split(' '))
G[s].add(t)
G[t].add(s)
points = find(G)
for p in sorted(points):
print p |
s974969402 | p02366 | u881590806 | 1490961371 | Python | Python | py | Runtime Error | 20 | 8120 | 1154 | def dfs(G,s,p,prenum,T,parents,lowest):
T[s] = set()
prenum[s] = p
lowest[s] = p
if len(G[s]) == 0: return p
for c in G[s]:
if c in T:
if lowest[s] > prenum[c]:
lowest[s] = prenum[c]
else:
p = dfs(G,c,p+1,prenum,T,parents,lowest)
T[s].add(c)
T[c].add(s)
parents[c] = s
lowest[s] = min(lowest[s], lowest[c])
return p
def find(G):
points = set()
lowest = {}
prenum = {}
parents = {0:None}
T = {}
dfs(G,0,1,prenum,T,parents,lowest)
#print G
#print T
#print prenum
#print lowest
#print parents
for s in T:
p = parents[s]
if p is None:
if len(T[s])>1: points.add(s)
else:
if parents[p] is None: continue
if prenum[p] <= lowest[s]:
points.add(p)
return points
n,m = map(int,raw_input().split(' '))
G = {}
for i in range(n):
G[i] = set()
for i in range(m):
s,t = map(int,raw_input().split(' '))
G[s].add(t)
G[t].add(s)
points = find(G)
for p in sorted(list(points)):
print p |
s494780311 | p02366 | u603049633 | 1496896569 | Python | Python3 | py | Runtime Error | 30 | 8780 | 1027 | V,E = map(int, input().split())
#??£??\??????????????????
A = [[] for i in range(V)]
for i in range(E):
s,t = map(int, input().split())
A[s].append(t)
A[t].append(s)
#?????????????¨???????
prenum = [None for i in range(V)]
#DFS???????????????????????????
parent = [None for i in range(V)]
#????????????????°??????????
lowest = [None for i in range(V)]
#?¨????????????°??????
visited = [False for i in range(V)]
def DFS(u = 0, prev = -1, timer = 0):
prenum[u] = timer
lowest[u] = timer
timer += 1
visited[u] = True
for v in A[u]:
if not visited[v]:
parent[v] = u
DFS(v, u, timer)
lowest[u] = min(lowest[u], lowest[v])
elif v != prev:
lowest[u] = min(lowest[u], prenum[v])
DFS()
ans = set()
for u in range(1, V):
p = parent[u]
if prenum[p] <= lowest[u]:
ans.add(p)
if parent.count(0) >= 2:
ans.add(0)
else:
ans.discard(0)
ans = list(ans)
ans.sort()
if ans:
print(*ans, sep = '\n') |
s337982752 | p02366 | u426534722 | 1501019833 | Python | Python3 | py | Runtime Error | 30 | 8952 | 939 | from sys import stdin
import sys
n, m = map(int, stdin.readline().split())
edges = [set() for _ in range(n)]
for _ in [0] * m:
s, t = map(int, stdin.readline().split())
edges[s].add(t)
edges[t].add(s)
prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0
def dfs(cur, prev):
global counter
prenum[cur] = lowest[cur] = counter
counter += 1
for edge in edges[cur]:
if prenum[edge] is not None:
if edge != prev:
lowest[cur] = min(lowest[cur], prenum[edge])
continue
parent[edge] = cur
dfs(edge, cur)
lowest[cur] = min(lowest[cur], lowest[edge])
dfs(0, 1)
ap = [False] * n
r = 0
for _ in filter(lambda x: x == 0, parent):
r += 1
if r > 1:
ap[0] = True
break
for i in range(1, n):
p = parent[i]
if p and prenum[p] <= lowest[i]:
ap[p] = True
for i, e in enumerate(ap):
if e: print(i) |
s674001603 | p02366 | u426534722 | 1501019883 | Python | Python3 | py | Runtime Error | 30 | 8908 | 928 | from sys import stdin
n, m = map(int, stdin.readline().split())
edges = [set() for _ in range(n)]
for _ in [0] * m:
s, t = map(int, stdin.readline().split())
edges[s].add(t)
edges[t].add(s)
prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0
def dfs(cur, prev):
global counter
prenum[cur] = lowest[cur] = counter
counter += 1
for edge in edges[cur]:
if prenum[edge] is not None:
if edge != prev:
lowest[cur] = min(lowest[cur], prenum[edge])
continue
parent[edge] = cur
dfs(edge, cur)
lowest[cur] = min(lowest[cur], lowest[edge])
dfs(0, 1)
ap = [False] * n
r = 0
for _ in filter(lambda x: x == 0, parent):
r += 1
if r > 1:
ap[0] = True
break
for i in range(1, n):
p = parent[i]
if p and prenum[p] <= lowest[i]:
ap[p] = True
for i, e in enumerate(ap):
if e: print(i) |
s867639661 | p02366 | u426534722 | 1501020047 | Python | Python3 | py | Runtime Error | 30 | 8520 | 773 | import sys
def dfs(v, tm):
dts[v] = est[v] = tm + 1
child = 0
for i in adj[v]:
if est[i] == float('inf'):
child += 1
parents[i] = v
dfs(i, tm + 1)
est[v] = min(est[v], est[i])
if parents[v] is None and child > 1: aps[v] = True
if parents[v] is not None and est[i] >= dts[v]: aps[v] = True
elif parents[v] != i:
est[v] = min(est[v], dts[i])
nv, ne = map(int, input().split(' '))
adj = [[] for _ in range(nv)]
est = [float('inf')] * nv
parents = [None] * nv
aps = [False] * nv
dts = [0] * nv
for _ in range(ne):
s, t = map(int, input().split(' '))
adj[s].append(t)
adj[t].append(s)
dfs(0, 0)
for i in range(nv):
if aps[i]:
print(i) |
s237376507 | p02366 | u881590806 | 1504195663 | Python | Python3 | py | Runtime Error | 60 | 9364 | 780 | prenum = {}
lowest = {}
parent = {}
visited = set()
def dfs(G, u, t):
prenum[u] = t
lowest[u] = t
visited.add(u)
for v in G[u]:
if v not in visited:
dfs(G, v, t+1)
lowest[u] = min(lowest[u], lowest[v])
parent[v] = u
else:
lowest[u] = min(lowest[u], prenum[v])
def solve(G):
dfs(G, 0, 0)
ret = set()
np = 0
for i in G:
if i not in parent:
continue
p = parent[i]
if p == 0:
np += 1
continue
if prenum[p] <= lowest[i]:
ret.add(p)
if np > 1:
ret.add(0)
return ret
n,m = list(map(int, input().split(' ')))
G = {}
for i in range(n):
G[i] = set()
for i in range(m):
s,t = list(map(int, input().split(' ')))
G[s].add(t)
G[t].add(s)
ret = solve(G)
for r in sorted(ret):
print(r) |
s410774057 | p02366 | u260980560 | 1507995564 | Python | Python3 | py | Runtime Error | 0 | 0 | 893 | def get_articulation_points(G, N, start=0):
v_min = [0]*N; order = [None]*N
result = []; count = 0
def dfs(v, prev):
nonlocal count
r_min = order[v] = count
fcnt = 0; p_art = 0
count += 1
for w in G[v]:
if w == prev:
continue
if order[w] is None:
ret = dfs(w, v)
p_art |= (ret == w)
r_min = min(r_min, ret)
fcnt += 1
else:
r_min = min(r_min, order[w])
if (prev == -1 and fcnt > 1) or (prev != -1 and p_art):
result.append(v)
return r_min
dfs(start, -1)
return result
n, m = map(int, input().split())
G = [[] for i in range(n)]
for i in range(m):
s, t = map(int, input().split())
G[s].append(t)
G[t].append(s)
[*map(print,sorted(get_articulation_points(G, n)))] |
s254297228 | p02366 | u260980560 | 1507996420 | Python | Python3 | py | Runtime Error | 60 | 8860 | 957 |
def get_articulation_points(G, N, start=0):
v_min = [0]*N; order = [None]*N
result = []; count = 0
def dfs(v, prev):
nonlocal count
r_min = order[v] = count
fcnt = 0; p_art = 0
count += 1
for w in G[v]:
if w == prev:
continue
if order[w] is None:
ret = dfs(w, v)
p_art |= (order[v] <= ret)
r_min = min(r_min, ret)
fcnt += 1
else:
r_min = min(r_min, order[w])
p_art |= (r_min == order[v] and len(G[v]) > 1)
if (prev == -1 and fcnt > 1) or (prev != -1 and p_art):
result.append(v)
return r_min
dfs(start, -1)
return result
n, m = map(int, input().split())
G = [[] for i in range(n)]
for i in range(m):
s, t = map(int, input().split())
G[s].append(t)
G[t].append(s)
*_,=map(print,sorted(get_articulation_points(G, n))) |
s145514849 | p02366 | u798803522 | 1508055253 | Python | Python3 | py | Runtime Error | 20 | 7968 | 1229 | from collections import defaultdict
def seq():
a = 1
while True:
yield a
a += 1
def dfs(here, went, connect, discovery, low, answer, seq):
went |= {here}
discovery[here] = low[here] = next(seq)
child = 0
for con in connect[here]:
if con not in went:
parent[con] = here
child += 1
dfs(con, went, connect, discovery, low, answer, seq)
low[here] = min(low[here], low[i])
if parent[here] is None and child >= 2:
answer.append(here)
elif parent[here] is not None and discovery[here] <= low[con]:
answer.append(here)
elif parent[here] != parent[con]:
low[here] = min(low[here], discovery[con])
vertices, edges = (int(n) for n in input().split(" "))
connect = defaultdict(list)
for _ in range(edges):
v1, v2 = (int(n) for n in input().split(" "))
connect[v1].append(v2)
connect[v2].append(v1)
answer = []
new_seq = seq()
went = set()
discovery = [None for n in range(vertices)]
low = [None for n in range(vertices)]
parent = [None for n in range(vertices)]
dfs(0, went, connect, discovery, low, answer, new_seq)
for a in sorted(answer):
print(a) |
s471486340 | p02366 | u798803522 | 1508055838 | Python | Python3 | py | Runtime Error | 80 | 9096 | 1267 | from collections import defaultdict
def seq():
a = 1
while True:
yield a
a += 1
def dfs(here, went, connect, discovery, low, answer, seq):
went |= {here}
discovery[here] = low[here] = next(seq)
child = 0
for con in connect[here]:
if con not in went:
parent[con] = here
child += 1
dfs(con, went, connect, discovery, low, answer, seq)
low[here] = min(low[here], low[con])
if parent[here] is None and child >= 2:
answer[here] = 1
elif parent[here] is not None and discovery[here] <= low[con]:
answer[here] = 1
elif parent[here] != con:
low[here] = min(low[here], discovery[con])
vertices, edges = (int(n) for n in input().split(" "))
connect = defaultdict(list)
for _ in range(edges):
v1, v2 = (int(n) for n in input().split(" "))
connect[v1].append(v2)
connect[v2].append(v1)
answer = [0 for n in range(vertices)]
new_seq = seq()
went = set()
discovery = [0 for n in range(vertices)]
low = [float("inf") for n in range(vertices)]
parent = [None for n in range(vertices)]
dfs(0, went, connect, discovery, low, answer, new_seq)
for i,n in enumerate(answer):
if n:
print(i) |
s236368384 | p02366 | u519227872 | 1508058831 | Python | Python3 | py | Runtime Error | 80 | 9296 | 883 | from collections import defaultdict
V, E = map(int, input().split())
G = defaultdict(list)
T = defaultdict(list)
for i in range(E):
s,t = map(int, input().split())
G[s].append(t)
G[t].append(s)
prenum = [float('inf')] * V
lowest = [float('inf')] * V
parent = [None] * V
visited = [False] * V
def dfs(g,s,c=0,p=None):
visited[s] = True
prenum[s] = c
lowest[s] = c
c+=1
for v in g[s]:
if not visited[v]:
parent[v] = s
T[v].append(s)
T[s].append(v)
dfs(g,v,c,s)
lowest[s] = min( lowest[s], lowest[v] )
elif v != p:
lowest[s] = min( lowest[s], prenum[v] )
dfs(G,0)
k = []
if len(T[0]) > 1: k.append(0)
for u in range(V):
p = parent[u]
if p is None or p == 0: continue
if prenum[p] <= lowest[u]: k.append(p)
for i in sorted(set(k)):
print(i) |
s575416220 | p02366 | u519227872 | 1508059074 | Python | Python3 | py | Runtime Error | 70 | 11012 | 943 | from collections import defaultdict
import sys
sys.setrecursionlimit(2*sys.getrecursionlimit())
V, E = map(int, input().split())
G = defaultdict(list)
T = defaultdict(list)
for i in range(E):
s,t = map(int, input().split())
G[s].append(t)
G[t].append(s)
prenum = [float('inf')] * V
lowest = [float('inf')] * V
parent = [None] * V
visited = [False] * V
def dfs(g,s,c=0,p=None):
visited[s] = True
prenum[s] = c
lowest[s] = c
c+=1
for v in g[s]:
if not visited[v]:
parent[v] = s
T[v].append(s)
T[s].append(v)
dfs(g,v,c,s)
lowest[s] = min( lowest[s], lowest[v] )
elif v != p:
lowest[s] = min( lowest[s], prenum[v] )
dfs(G,0)
k = []
if len(T[0]) > 1: k.append(0)
for u in range(V):
p = parent[u]
if p is None or p == 0: continue
if prenum[p] <= lowest[u]: k.append(p)
for i in sorted(set(k)):
print(i) |
s365409982 | p02366 | u519227872 | 1508059097 | Python | Python3 | py | Runtime Error | 60 | 10916 | 943 | from collections import defaultdict
import sys
sys.setrecursionlimit(3*sys.getrecursionlimit())
V, E = map(int, input().split())
G = defaultdict(list)
T = defaultdict(list)
for i in range(E):
s,t = map(int, input().split())
G[s].append(t)
G[t].append(s)
prenum = [float('inf')] * V
lowest = [float('inf')] * V
parent = [None] * V
visited = [False] * V
def dfs(g,s,c=0,p=None):
visited[s] = True
prenum[s] = c
lowest[s] = c
c+=1
for v in g[s]:
if not visited[v]:
parent[v] = s
T[v].append(s)
T[s].append(v)
dfs(g,v,c,s)
lowest[s] = min( lowest[s], lowest[v] )
elif v != p:
lowest[s] = min( lowest[s], prenum[v] )
dfs(G,0)
k = []
if len(T[0]) > 1: k.append(0)
for u in range(V):
p = parent[u]
if p is None or p == 0: continue
if prenum[p] <= lowest[u]: k.append(p)
for i in sorted(set(k)):
print(i) |
s010245125 | p02366 | u519227872 | 1508059120 | Python | Python3 | py | Runtime Error | 60 | 11012 | 943 | from collections import defaultdict
import sys
sys.setrecursionlimit(5*sys.getrecursionlimit())
V, E = map(int, input().split())
G = defaultdict(list)
T = defaultdict(list)
for i in range(E):
s,t = map(int, input().split())
G[s].append(t)
G[t].append(s)
prenum = [float('inf')] * V
lowest = [float('inf')] * V
parent = [None] * V
visited = [False] * V
def dfs(g,s,c=0,p=None):
visited[s] = True
prenum[s] = c
lowest[s] = c
c+=1
for v in g[s]:
if not visited[v]:
parent[v] = s
T[v].append(s)
T[s].append(v)
dfs(g,v,c,s)
lowest[s] = min( lowest[s], lowest[v] )
elif v != p:
lowest[s] = min( lowest[s], prenum[v] )
dfs(G,0)
k = []
if len(T[0]) > 1: k.append(0)
for u in range(V):
p = parent[u]
if p is None or p == 0: continue
if prenum[p] <= lowest[u]: k.append(p)
for i in sorted(set(k)):
print(i) |
s923190449 | p02366 | u662418022 | 1519735513 | Python | Python3 | py | Runtime Error | 30 | 7052 | 1172 | # -*- coding: utf-8 -*-
if __name__ == '__main__':
n, m = [int(s) for s in input().split()]
E = [set() for _ in range(n)]
for _ in range(m):
s, t = [int(s) for s in input().split(" ")]
E[s].add(t)
E[t].add(s)
def dfs(current, prev):
global timer
prenum[current] = timer
lowest[current] = prenum[current]
timer += 1
visited[current] = 1
for v in E[current]:
if visited[v] == 0:
parent[v] = current
dfs(v, current)
lowest[current] = min(lowest[current], lowest[v])
elif v != prev: # current -> v is back-edge
lowest[current] = min(lowest[current], prenum[v])
prenum = [None] * n
parent = [None] * n
lowest = [float("inf")] * n
timer = 1
visited = [0] * n
dfs(0, -1)
ap = []
np = 0
for i in range(1, n):
p = parent[i]
if p == 0:
np += 1
elif prenum[p] <= lowest[i]:
ap.append(p)
if np > 1:
ap.append(0)
ap = list(set(ap))
ap.sort()
if ap:
print("\n".join(map(str, ap)))
|
s303842990 | p02367 | u967553879 | 1556843407 | Python | Python3 | py | Runtime Error | 0 | 0 | 1310 | from collections import deque
sys.setrecursionlimit(1000000)
def dfs(current, prev):
global time
# node currentを訪問した直後の処理
ord[current] = time
low[current] = time
time += 1
color[current] = BLACK
for next in G[current]:
if color[next] == WHITE:
# node currentからnode nextへ訪問する直前の処理
parent[next] = current
dfs(next, current)
# node nextの探索が終了した直後の処理
low[current] = min(low[current], low[next])
elif next != prev:
# edge current --> next がback-edgeの場合の処理
low[current] = min(low[current], ord[next])
def bridge():
global time
time = 1
dfs(0, -1) # 0をrootとしてlowの計算
for u, v in edges:
if ord[u] < low[v] or ord[v] < low[u]:
br.add((u, v))
G = {}
edges = set([])
br = set([])
v, n = map(int, input().split())
for i in range(0, v):
G[i] = []
for i in range(n):
s, t = map(int, input().split())
G[s].append(t)
G[t].append(s)
edges.add((s, t))
WHITE = 0
BLACK = 2
color = [WHITE] * (v)
parent = [0] * (v)
ord = [0] * (v)
low = [0] * (v)
parent = [0] * (v)
bridge()
if br:
for ans in sorted(br):
print(*ans, sep=' ')
|
s729066645 | p02367 | u797673668 | 1461576355 | Python | Python3 | py | Runtime Error | 40 | 8992 | 797 | n, m = map(int, input().split())
edges = [set() for _ in range(n)]
for _ in range(m):
s, t = map(int, input().split())
edges[s].add(t)
edges[t].add(s)
prenum = [None] * n
parent = [None] * n
lowest = [None] * n
counter = 0
bridges = set()
def dfs(cur, prev):
global counter
prenum[cur] = lowest[cur] = counter
counter += 1
for edge in edges[cur]:
if prenum[edge] is not None:
if edge != prev:
lowest[cur] = min(lowest[cur], prenum[edge])
continue
parent[edge] = cur
dfs(edge, cur)
lowest[cur] = min(lowest[cur], lowest[edge])
if prenum[cur] == lowest[cur]:
bridges.add((cur, prev) if cur < prev else (prev, cur))
dfs(0, -1)
for bridge in sorted(bridges)[1:]:
print(*bridge) |
s408332130 | p02367 | u022407960 | 1480484486 | Python | Python3 | py | Runtime Error | 30 | 8956 | 2160 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
0 1
1 2
2 3
3 4
"""
import sys
# sys.setrecursionlimit(int(3e6))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(u, visited, parent, low, disc):
global Time
# Count of children in current node
children = 0
# Mark the current node as visited and print it
visited[u] = True
# Initialize discovery time and low value
disc[u] = Time
low[u] = Time
Time += 1
# Recur for all the vertices adjacent to this vertex
for v in adj_table[u]:
# If v is not visited yet, then make it a child of u
# in DFS tree and recur for it
if not visited[v]:
parent[v] = u
children += 1
graph_dfs(v, visited, parent, low, disc)
# Check if the subtree rooted with v has a connection to
# one of the ancestors of u
low[u] = min(low[u], low[v])
''' If the lowest vertex reachable from subtree
under v is below u in DFS tree, then u-v is
a bridge'''
if low[v] > disc[u]:
ans.append(sorted([u, v]))
elif v != parent[u]: # Update low value of u for parent function calls.
low[u] = min(low[u], disc[v])
return None
def bridge():
visited = [False] * vertices
disc = [float("Inf")] * vertices
low = [float("Inf")] * vertices
parent = [-1] * vertices
for v in range(vertices):
if not visited[v]:
graph_dfs(v, visited, parent, low, disc)
return ans
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
Time = 0
ans = []
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
res = bridge()
res.sort()
for ele in res:
print(*ele) |
s878913971 | p02367 | u022407960 | 1480484549 | Python | Python3 | py | Runtime Error | 0 | 0 | 2159 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
0 1
1 2
2 3
3 4
"""
import sys
sys.setrecursionlimit(int(1e10))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
# undirected graph
init_adj_table[v_to].append(v_from)
return init_adj_table
def graph_dfs(u, visited, parent, low, disc):
global Time
# Count of children in current node
children = 0
# Mark the current node as visited and print it
visited[u] = True
# Initialize discovery time and low value
disc[u] = Time
low[u] = Time
Time += 1
# Recur for all the vertices adjacent to this vertex
for v in adj_table[u]:
# If v is not visited yet, then make it a child of u
# in DFS tree and recur for it
if not visited[v]:
parent[v] = u
children += 1
graph_dfs(v, visited, parent, low, disc)
# Check if the subtree rooted with v has a connection to
# one of the ancestors of u
low[u] = min(low[u], low[v])
''' If the lowest vertex reachable from subtree
under v is below u in DFS tree, then u-v is
a bridge'''
if low[v] > disc[u]:
ans.append(sorted([u, v]))
elif v != parent[u]: # Update low value of u for parent function calls.
low[u] = min(low[u], disc[v])
return None
def bridge():
visited = [False] * vertices
disc = [float("Inf")] * vertices
low = [float("Inf")] * vertices
parent = [-1] * vertices
for v in range(vertices):
if not visited[v]:
graph_dfs(v, visited, parent, low, disc)
return ans
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
Time = 0
ans = []
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
res = bridge()
res.sort()
for ele in res:
print(*ele) |
s427778962 | p02367 | u798803522 | 1508077762 | Python | Python3 | py | Runtime Error | 0 | 0 | 1232 | from collections import defaultdict
import sys
sys.setrecursionlimit(100000)
def seq():
a = 1
while True:
yield a
a += 1
def dfs(here, went, connect, discovery, low, answer, seq):
went |= {here}
discovery[here] = low[here] = next(seq)
child = 0
for con in connect[here]:
if con not in went:
parent[con] = here
child += 1
dfs(con, went, connect, discovery, low, answer, seq)
low[here] = min(low[here], low[con])
if discovery[here] < low[con]:
answer[min(here,con)].append(max(here,con))
elif parent[here] != con:
low[here] = min(low[here], discovery[con])
vertices, edges = (int(n) for n in input().split(" "))
connect = defaultdict(list)
for _ in range(edges):
v1, v2 = (int(n) for n in input().split(" "))
connect[v1].append(v2)
connect[v2].append(v1)
answer = defaultdict(list)
new_seq = seq()
went = set()
discovery = [0 for n in range(vertices)]
low = [float("inf") for n in range(vertices)]
parent = [None for n in range(vertices)]
dfs(0, went, connect, discovery, low, answer, new_seq)
for k in range(answer.keys()):
for n in range(answer[k]):
print(k,n) |
s986602917 | p02367 | u798803522 | 1508077844 | Python | Python3 | py | Runtime Error | 0 | 0 | 1232 | from collections import defaultdict
import sys
sys.setrecursionlimit(100000)
def seq():
a = 1
while True:
yield a
a += 1
def dfs(here, went, connect, discovery, low, answer, seq):
went |= {here}
discovery[here] = low[here] = next(seq)
child = 0
for con in connect[here]:
if con not in went:
parent[con] = here
child += 1
dfs(con, went, connect, discovery, low, answer, seq)
low[here] = min(low[here], low[con])
if discovery[here] < low[con]:
answer[min(here,con)].append(max(here,con))
elif parent[here] != con:
low[here] = min(low[here], discovery[con])
vertices, edges = (int(n) for n in input().split(" "))
connect = defaultdict(list)
for _ in range(edges):
v1, v2 = (int(n) for n in input().split(" "))
connect[v1].append(v2)
connect[v2].append(v1)
answer = defaultdict(list)
new_seq = seq()
went = set()
discovery = [0 for n in range(vertices)]
low = [float("inf") for n in range(vertices)]
parent = [None for n in range(vertices)]
dfs(0, went, connect, discovery, low, answer, new_seq)
for k in range(answer.keys()):
for n in range(answer[k]):
print(k,n) |
s204853134 | p02368 | u567380442 | 1428195864 | Python | Python3 | py | Runtime Error | 0 | 0 | 1664 | def search(g, v):
visited = set()
lowest = [None] * v
parent = [None] * v
prenum = [None] * v
child = defaultdict(list)
root = 0
# dfs??§tree?????????
stack = [(root, None)]
while stack:
u, prev = stack.pop()
if u not in visited:
parent[u] = prev
if prev is not None:
child[prev].append(u)
visited |= {u}
prenum[u] = lowest[u] = len(visited)
stack.extend([(v, u) for v in g[u] if v not in visited])
# lowest????¨????
from collections import Counter
leaf = [i for i in range(v) if not child[i]]
unfinished = Counter()
for li in leaf:
while li is not None:
# candidate = [prenum[li]] + [prenum[i] for i in g[li] if i != parent[li]] + [lowest[i] for i in child[li]] #???undirected
candidate = [prenum[li]] + [prenum[i] for i in g[li]] + [lowest[i] for i in child[li]] # directed
lowest[li] = min(candidate)
li = parent[li]
if li is not None and 1 < len(child[li]):
unfinished[li] += 1
if unfinished[li] < len(child[li]):
break
return prenum, lowest
from sys import stdin
readline = stdin.readline
def main():
v, e = map(int, readline().split())
from collections import defaultdict
g = defaultdict(list)
for _ in range(e):
s, t = map(int, readline().split())
g[s].append(t)
prenum, lowest = search(g, v)
q = int(readline())
for u, v in [map(int, readline().split()) for _ in range(q)]:
print(1 if lowest[u] == lowest[v] else 0)
main() |
s157612326 | p02368 | u567380442 | 1428195926 | Python | Python3 | py | Runtime Error | 30 | 6800 | 1700 | def search(g, v):
visited = set()
lowest = [None] * v
parent = [None] * v
prenum = [None] * v
child = defaultdict(list)
root = 0
# dfs??§tree?????????
stack = [(root, None)]
while stack:
u, prev = stack.pop()
if u not in visited:
parent[u] = prev
if prev is not None:
child[prev].append(u)
visited |= {u}
prenum[u] = lowest[u] = len(visited)
stack.extend([(v, u) for v in g[u] if v not in visited])
# lowest????¨????
from collections import Counter
leaf = [i for i in range(v) if not child[i]]
unfinished = Counter()
for li in leaf:
while li is not None:
# candidate = [prenum[li]] + [prenum[i] for i in g[li] if i != parent[li]] + [lowest[i] for i in child[li]] #???undirected
candidate = [prenum[li]] + [prenum[i] for i in g[li]] + [lowest[i] for i in child[li]] # directed
lowest[li] = min(candidate)
li = parent[li]
if li is not None and 1 < len(child[li]):
unfinished[li] += 1
if unfinished[li] < len(child[li]):
break
return prenum, lowest
from collections import defaultdict
from sys import stdin
readline = stdin.readline
def main():
v, e = map(int, readline().split())
from collections import defaultdict
g = defaultdict(list)
for _ in range(e):
s, t = map(int, readline().split())
g[s].append(t)
prenum, lowest = search(g, v)
q = int(readline())
for u, v in [map(int, readline().split()) for _ in range(q)]:
print(1 if lowest[u] == lowest[v] else 0)
main() |
s117398597 | p02368 | u567380442 | 1428207239 | Python | Python3 | py | Runtime Error | 0 | 0 | 1762 | from collections import defaultdict
from collections import Counter
def search(g, v):
visited = set()
lowest = [None] * v
parent = [None] * v
prenum = [None] * v
child = defaultdict(list)
backtrack = defaultdict(set)
for root in range(v):
if root in visited:
continue
route = Stack()
route.push(None)
dfs_stack = [(root, route[-1])]
while dfs_stack:
u, prev = dfs_stack.pop()
if u in visited:
continue
parent[u] = prev
if prev is not None:
child[prev].append(u)
visited |= {u}
prenum[u] = lowest[u] = len(visited)
while route[-1] != prev:
route.pop()
backtrack[u] = route & g[u]
route.push(u)
dfs_stack.extend((v, u) for v in g[u] - visited)
from heapq import heappush, heappop
heap = []
for i in range(v):
if backtrack[i]:
heappush(heap, (prenum[i], i))
while heap:
_, i = heappop(heap)
low, bi = min((lowest[bi], bi) for bi in backtrack[i])
while i != bi:
lowest[i] = low
i = parent[i]
return prenum, lowest
from sys import stdin
readline = stdin.readline
def main():
v, e = map(int, readline().split())
from collections import defaultdict
g = defaultdict(set)
for _ in range(e):
s, t = map(int, readline().split())
g[s] |= {t}
prenum, lowest = search(g, v)
q = int(readline())
for u, v in [map(int, readline().split()) for _ in range(q)]:
print(1 if lowest[u] == lowest[v] else 0)
main() |
s111787803 | p02368 | u797673668 | 1461579413 | Python | Python3 | py | Runtime Error | 140 | 8436 | 1019 | def f_dfs(i):
global f_edges, counter
visited[i] = True
for edge in f_edges[i]:
if visited[edge]:
continue
f_dfs(edge)
finish_order[i] = (counter, i)
counter += 1
def b_dfs(i, group):
global b_edges, groups
visited[i] = True
groups[i] = group
for edge in b_edges[i]:
if visited[edge]:
continue
b_dfs(edge, group)
n, m = map(int, input().split())
f_edges = [set() for _ in range(n)]
b_edges = [set() for _ in range(n)]
for _ in range(m):
s, t = map(int, input().split())
f_edges[s].add(t)
b_edges[t].add(s)
visited = [False] * n
finish_order = [None] * n
counter = 0
for i in range(n):
if not visited[i]:
f_dfs(i)
visited = [False] * n
groups = [None] * n
group = 0
for d, i in sorted(finish_order, reverse=True):
if not visited[i]:
b_dfs(i, group)
group += 1
q = int(input())
while q:
q -= 1
u, v = map(int, input().split())
print(int(groups[u] == groups[v])) |
s184108483 | p02368 | u022407960 | 1480492151 | Python | Python3 | py | Runtime Error | 90 | 9844 | 2759 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
sys.setrecursionlimit(int(1e4))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
return init_adj_table
def graph_dfs(u, low, disc, stack_member, st):
global Time
# Initialize discovery time and low value
disc[u] = Time
low[u] = Time
Time += 1
stack_member[u] = True
st.append(u)
scc_set = set()
# Go through all vertices adjacent to this
for v in adj_table[u]:
# If v is not visited yet, then recur for it
if disc[v] == -1:
graph_dfs(v, low, disc, stack_member, st)
# Check if the subtree rooted with v has a connection to
# one of the ancestors of u
# Case 1 (per above discussion on Disc and Low value)
low[u] = min(low[u], low[v])
elif stack_member[v]:
'''Update low value of 'u' only if 'v' is still in stack
(i.e. it's a back edge, not cross edge).
Case 2 (per above discussion on Disc and Low value) '''
low[u] = min(low[u], disc[v])
# head node found, pop the stack and print an SCC
w = -1 # To store stack extracted vertices
if low[u] == disc[u]:
while w != u:
w = st.pop()
scc_set.add(w)
stack_member[w] = False
ans.append(scc_set)
return None
def scc():
# Mark all the vertices as not visited
# and Initialize parent and visited,
# and ap(articulation point) arrays
disc = [-1] * vertices
low = [-1] * vertices
stack_member = [False] * vertices
st = []
# Call the recursive helper function
# to find articulation points
# in DFS tree rooted with vertex 'i'
for v in range(vertices):
if disc[v] == -1:
graph_dfs(v, low, disc, stack_member, st)
return ans
def solve():
for question in q_list:
flag = False
ele1, ele2 = map(int, question)
for each in scc_sets:
if (ele1 in each) and (ele2 in each):
flag = True
if flag:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:edges + 1])
q_num = int(_input[edges + 1])
q_list = map(lambda x: x.split(), _input[edges + 2:])
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
Time = 0
ans = []
scc_sets = scc()
solve() |
s800372080 | p02368 | u022407960 | 1480527058 | Python | Python3 | py | Runtime Error | 210 | 67532 | 2395 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e6))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = map(int, v_detail)
init_adj_table[v_from].append(v_to)
return init_adj_table
def Tarjan(current, low, disc, visited, scc_stack, in_scc_stack):
global timer
disc[current] = low[current] = timer
timer += 1
visited[current] = True
scc_stack.append(current)
in_scc_stack[current] = True
current_scc_set = set()
for adj in adj_table[current]:
if not isinf(disc[adj]):
Tarjan(adj, low, disc, visited, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
elif in_scc_stack[adj]:
low[current] = min(low[current], disc[adj])
scc_candidate = -1
if disc[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
current_scc_set.add(scc_candidate)
visited[scc_candidate] = False
in_scc_stack[scc_candidate] = False
init_scc_sets_list.append(current_scc_set)
return None
def scc():
disc = [float('inf')] * vertices
low = [float('inf')] * vertices
visited = [False] * vertices
scc_stack = list()
in_scc_stack = [False] * vertices
for v in range(vertices):
if isinf(disc[v]):
Tarjan(v, low, disc, visited, scc_stack, in_scc_stack)
return init_scc_sets_list
def solve():
for question in q_list:
flag = False
ele1, ele2 = map(int, question)
for each in scc_sets_list:
if (ele1 in each) and (ele2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
return scc_sets_list
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:edges + 1])
q_num = int(_input[edges + 1])
q_list = map(lambda x: x.split(), _input[edges + 2:])
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
timer = 0
init_scc_sets_list = []
scc_sets_list = scc()
res = solve() |
s608785094 | p02368 | u894114233 | 1482652349 | Python | Python | py | Runtime Error | 40 | 6508 | 991 | def add_edge(frm,to):
g[frm].append(to)
rg[to].append(frm)
def dfs(now,used,back_track):
used[now]=True
for nx in g[now]:
if not used[nx]:dfs(nx,used,back_track)
back_track.append(now)
def rdfs(now,num_cmp,used,cmp):
used[now]=True
cmp[now]=num_cmp
for nx in rg[now]:
if not used[nx]:rdfs(nx,num_cmp,used,cmp)
def scc(n):
used=[False]*n
back_track=[]
cmp=[-1]*n
for v in xrange(n):
if not used[v]:dfs(v,used,back_track)
used=[False]*n
num_cmp=0
for v in back_track[::-1]:
if not used[v]:
rdfs(v,num_cmp,used,cmp)
num_cmp+=1
return num_cmp,cmp
n,m=map(int,raw_input().split())
g=[[] for _ in xrange(n)]
rg=[[] for _ in xrange(n)]
for i in xrange(m):
s,t=map(int,raw_input().split())
add_edge(s,t)
num,cmp=scc(n)
q=int(raw_input())
for i in xrange(q):
u,v=map(int,raw_input().split())
if cmp[u]==cmp[v]:
print(1)
else:
print(0) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.