input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import heapq
def sol(inp=input):
n,m=list(map(int,inp().split()))
G={i+1:set() for i in range(n)}
for _ in range(m):
i,j=list(map(int,inp().split()))
G[i].add(j)
s,t=list(map(int,inp().split()))
cache_kenken={}
def kenken(v):
if v not in cache_kenken:
cache_kenken[v]=set(v2 for v1 in G[v] for v2 in G[v1])
return cache_kenken[v]
def kenkenpa(v):
return set(v3 for v2 in kenken(v) for v3 in G[v2])
visited={s}
revisited=set()
v_steps=[]
visited_pa={s}
que=[]
heapq.heappush(que,(0,s))
while len(que)>0:
step,u=heapq.heappop(que)
for v in kenkenpa(u):
if v not in visited:
visited.add(v)
v_steps.append((step+1,v))
heapq.heappush(que,(step+1,v))
if v==t:
return step+1
if v not in visited:
visited.add(v)
return -1
print((sol())) | import heapq
def sol(inp=input):
s=3
n,m=list(map(int,inp().split()))
G={(i+1,j):set() for i in range(n) for j in range(s)}
for _ in range(m):
u,v=list(map(int,inp().split()))
for i in range(s):
G[(u,i)].add((v,(i+1)%s))
s,t=list(map(int,inp().split()))
visited={(s,0)}
que=[]
heapq.heappush(que,(0,(s,0)))
while len(que)>0:
step,u=heapq.heappop(que)
for v in G[u]:
if v not in visited:
visited.add(v)
heapq.heappush(que,(step+1,v))
if v==(t,0):
return (step+1)//3
return -1
print((sol())) | p02991 |
import copy
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]
s,t=list(map(int,input().split()))
connection=[[] for i in range(3*n)]
for i in range(m):
connection[l[i][0]-1].append(l[i][1]-1+n)
connection[l[i][0]-1+n].append(l[i][1]-1+2*n)
connection[l[i][0]-1+2*n].append(l[i][1]-1)
distance=[-1 for i in range(3*n)]
distance[s-1]=0
L=[s-1]
L2=[]
L3=[]
ct=1
while len(L2)!=3*n and len(L)!=0:
for j in range(len(L)):
for k in range(len(connection[L[j]])):
if distance[connection[L[j]][k]]==-1:
distance[connection[L[j]][k]]=ct
L3.append(connection[L[j]][k])
L2.append(L[j])
L=copy.copy(L3)
L3=[]
ct+=1
if distance[t-1]==-1:
print((-1))
else:
x=distance[t-1]-distance[s-1]
if x%3==0:
print((x//3))
else:
print((-1)) | n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]
s,t=list(map(int,input().split()))
connection=[[] for i in range(3*n)]
for i in range(m):
connection[l[i][0]-1].append(l[i][1]-1+n)
connection[l[i][0]-1+n].append(l[i][1]-1+2*n)
connection[l[i][0]-1+2*n].append(l[i][1]-1)
def bfs(v):
distance=[-1]*(3*n)
distance[v]=0
next=connection[v]
next2=set()
visited=[-1]*(3*n)
visited[v]=1
visitct=1
ct=0
while len(next)!=0 and visitct!=3*n:
ct+=1
for i in range(len(next)):
if visited[next[i]]==-1:
distance[next[i]]=ct
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
if bfs(s-1)[t-1]==-1 or bfs(s-1)[t-1]%3!=0:
print((-1))
else:
print((bfs(s-1)[t-1]//3)) | p02991 |
N,M = list(map(int,input().split()))
path = [[] for _ in range(N*3+3)]
for _ in range(M):
u,v = list(map(int,input().split()))
path[u].append(v+N)
path[u+N].append(v+N+N)
path[u+N+N].append(v)
S,T = list(map(int,input().split()))
import collections
q = collections.deque()
vis = [-1 for _ in range(N*3+3)]
def bfs():
while len(q) > 0:
now,cnt = q.popleft()
#print(now,T,cnt,path[now],q)
vis[now] = cnt
if now == T:
return cnt
for x in path[now]:
if vis[x] == -1:
q.append((x,cnt+1))
return -3
vis[S] = 1
q.append([S,0])
print((bfs()//3))
| N,M = list(map(int,input().split()))
path = [[] for _ in range(N*3+3)]
for _ in range(M):
u,v = list(map(int,input().split()))
path[u].append(v+N)
path[u+N].append(v+N+N)
path[u+N+N].append(v)
S,T = list(map(int,input().split()))
import collections
q = collections.deque()
vis = [-1 for _ in range(N*3+3)]
def bfs():
while len(q) > 0:
now,cnt = q.popleft()
#print(now,T,cnt,path[now],q)
vis[now] = cnt
if now == T:
return cnt
[q.append((x,cnt+1)) for x in path[now] if vis[x] == -1]
#for x in path[now]:
# if vis[x] == -1:
# q.append((x,cnt+1))
return -3
vis[S] = 1
q.append([S,0])
print((bfs()//3))
| p02991 |
N,M = list(map(int,input().split()))
import time
start_t = time.time()
path = [[] for _ in range(N+3)]
for _ in range(M):
u,v = list(map(int,input().split()))
path[u].append(v)
S,T = list(map(int,input().split()))
import collections
q = collections.deque()
vis = [[-1 for _ in range(3)] for _ in range(N+3)]
vis[S][0] = 1
q.append([S,0])
while len(q):
now,cnt = q.popleft()
step = cnt % 3
vis[now][step] = cnt
for x in path[now]:
if vis[x][(step+1)%3] < 0:
q.append((x,cnt+1))
if vis[T][0] == -1:
print((-1))
else:
print((vis[T][0]//3))
| N,M = list(map(int,input().split()))
import time
start_t = time.time()
path = [[] for _ in range(N+3)]
for _ in range(M):
u,v = list(map(int,input().split()))
path[u].append(v)
S,T = list(map(int,input().split()))
import collections
q = collections.deque()
vis = [[-1 for _ in range(3)] for _ in range(N+3)]
vis[S][0] = 1
q.append([S,0])
while len(q):
now,cnt = q.popleft()
step = cnt % 3
for x in path[now]:
if vis[x][(step+1)%3] < 0:
vis[x][(step+1)%3] = cnt
q.append((x,cnt+1))
if vis[T][0] == -1:
print((-1))
else:
print((vis[T][0]//3+1))
| p02991 |
def main():
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
edge[u-1].append(v-1)
d = [-1]*N
S, T = list(map(int, input().split()))
d[S-1] = 0
que = [S-1]
while len(que)>0:
now = que.pop(0)
for i in edge[now]:
for j in edge[i]:
for k in edge[j]:
if d[k] == -1:
que.append(k)
d[k] = d[now]+1
print((d[T-1]))
if __name__ == "__main__":
main() | def main():
N, M = list(map(int, input().split()))
edge = [[[] for _ in range(3)] for _ in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
edge[u-1][0].append([v-1,1])
edge[u-1][1].append([v-1,2])
edge[u-1][2].append([v-1,0])
d = [[-1]*3 for _ in range(N)]
S, T = list(map(int, input().split()))
d[S-1][0] = 0
que = [[S-1, 0]]
while len(que)>0:
now = que.pop(0)
for nex in edge[now[0]][now[1]]:
if d[nex[0]][nex[1]] != -1:continue
d[nex[0]][nex[1]] = d[now[0]][now[1]]
if now[1] == 2:
d[nex[0]][nex[1]] += 1
que.append(nex)
print((d[T-1][0]))
if __name__ == "__main__":
main() | p02991 |
import sys
from collections import deque
N, M = list(map(int, sys.stdin.readline().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
u, v = list(map(int, sys.stdin.readline().split()))
edges[u-1].append(v-1)
S, T = list(map(int, sys.stdin.readline().split()))
S -= 1
T -= 1
visited = {}
q = deque()
q.append((S, 0))
d = -1
while q:
s, c = q.popleft()
if s in visited and visited[s] % 3 == c % 3:
continue
visited[s] = c
for n in edges[s]:
if n == T and c % 3 == 2:
d = c + 1
break
q.append((n, c+1))
if d % 3 == 0:
break
if d == -1:
print((-1))
else:
print((d // 3)) | import sys
from collections import deque
N, M = list(map(int, sys.stdin.readline().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
u, v = list(map(int, sys.stdin.readline().split()))
edges[u-1].append(v-1)
S, T = list(map(int, sys.stdin.readline().split()))
S -= 1
T -= 1
visited = {}
q = deque()
q.append((S, 0))
d = -1
while q:
s, c = q.popleft()
if s in visited and (c % 3) in visited[s]:
continue
if s not in visited:
visited[s] = set()
visited[s].add(c % 3)
for n in edges[s]:
if n == T and c % 3 == 2:
d = c + 1
break
q.append((n, c+1))
if d % 3 == 0:
break
if d == -1:
print((-1))
else:
print((d // 3)) | p02991 |
from collections import deque
N,M=list(map(int,input().split()))
# 頂点の番号は0-initialのまま扱う
E=set() # 辺から成るset
for i in range(M):
u,v=list(map(int,input().split()))
E.add((u,v))
S,T=list(map(int,input().split()))
d1=[set() for i in range(N+1)] # d1[i]=頂点iからの距離が1であるような頂点vから成るset
for e in E:
u=e[0];v=e[1]
d1[u].add(v)
d2=[set() for i in range(N+1)] # d2[i]=頂点iからの距離が2であるような頂点vから成るset
for e in E:
u=e[0];v=e[1]
d2[u].update(d1[v])
d3=[set() for i in range(N+1)]
for e in E:
u=e[0];v=e[1]
d3[u].update(d2[v])
'''
print(e)
print(d1)
print(d2)
print(d3)
'''
dis=[-1 for i in range(N+1)];dis[S]=0 # 頂点Sからの距離
# WFS
q=deque() # 遅ければlistで実装
q.append(S)
while q:
# print(q) #DB
# print(dis) #DB
u=q.popleft()
vs=[v for v in d3[u] if dis[v]==-1]
for v in vs:
dis[v]=dis[u]+1
q.extend(vs)
print((dis[T])) | from collections import deque
N,M=list(map(int,input().split()))
a=[set() for i in range(N)] # 0-index
for i in range(M):
u,v=[int(x)-1 for x in input().split()]
a[u].add(v)
S,T=[int(x)-1 for x in input().split()]
# print(a)
t=[]
for i in range(N):
ti=set()
for u in a[i]:
for v in a[u]:
for w in a[v]:
ti|={w}
t.append(ti)
# print(t)
r=[-1 for i in range(N)]
q=deque()
q.append(S);r[S]=0
while q:
u=q.popleft()
for v in t[u]:
if r[v]==-1:
r[v]=r[u]+1
q.append(v)
# print(r)
print((r[T])) | p02991 |
from collections import deque
N, M = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(M)]
S, T = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for u, v in edges:
graph[u].append(v)
INF = 10 ** 9 + 7
dp = [[INF] * (N + 1) for _ in range(3)]
dp[0][S] = 0
q = deque()
q.append((S, 0))
while q:
v, t = q.popleft()
u = (t + 1) % 3
d = dp[t][v]
if t == 2:
d += 1
for w in graph[v]:
if dp[u][w] != INF:
continue
dp[u][w] = d
q.append((w, u))
print((dp[0][T] if dp[0][T] < INF else -1))
| from collections import deque
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(M)]
S, T = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for u, v in X:
graph[u].append(v)
INF = 10 ** 9 + 7
ctr = [[INF] * (N + 1) for _ in range(3)]
ctr[0][S] = 0
stack = deque()
stack.append((0, S))
while stack:
i, u = stack.popleft()
j = (i + 1) % 3
for v in graph[u]:
if ctr[j][v] > ctr[i][u] + 1:
ctr[j][v] = ctr[i][u] + 1
stack.append((j, v))
if ctr[0][T] < INF:
print((ctr[0][T] // 3))
else:
print((-1))
| p02991 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
def LI(): return list(map(int, sys.stdin.readline().split()))
N,M = LI()
um = [[] for i in range(M)]
for i in range(M):
um[i] = LI()
S,T = LI()
S -= 1
T -= 1
routes = {}
for i in range(N):
routes[i] = []
for i in range(M):
u,m = um[i]
u -= 1
m -= 1
routes[u].append(m)
used = {}
for i in range(N):
used[i] = -1
# print(routes)
def skip(now,move_cnt):
flag = True
if move_cnt % 3 == 0:
if used[now] == -1:
used[now] = move_cnt//3
elif used[now] > move_cnt//3:
used[now] = move_cnt//3
else:
flag = False
if flag:
for route in routes[now]:
skip(route,move_cnt+1)
skip(S,0)
try:
ans = used[T]
except:
ans = -1
print(ans)
| # encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
def LI(): return list(map(int, sys.stdin.readline().split()))
N,M = LI()
um = [[] for i in range(M)]
for i in range(M):
um[i] = LI()
S,T = LI()
S -= 1
T -= 1
routes = [[] for i in range(N)]
for i in range(M):
u,m = um[i]
u -= 1
m -= 1
routes[u].append(m)
used = [-1 for i in range(N)]
# print(routes)
def skip(now,move_cnt):
flag = True
if move_cnt % 3 == 0:
if used[now] == -1:
used[now] = move_cnt//3
elif used[now] > move_cnt//3:
used[now] = move_cnt//3
else:
flag = False
if flag:
for route in routes[now]:
skip(route,move_cnt+1)
skip(S,0)
try:
ans = used[T]
except:
ans = -1
print(ans)
| p02991 |
n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
alist = [[] for _ in range(n)]
for u, v in uv:
alist[u-1].append(v-1)
s, t = list(map(int, input().split()))
alist3 = [set([]) for _ in range(n)]
for v in range(n):
for v1 in alist[v]:
for v2 in alist[v1]:
for v3 in alist[v2]:
alist3[v].add(v3)
# BFS
queue = [s-1]
visited = [-1]*n
visited[s-1] = 0
while len(queue) > 0:
q = queue.pop(0)
for v in alist3[q]:
if visited[v] < 0:
queue.append(v)
visited[v] = visited[q] + 1
print((visited[t-1]))
| n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
alist = [[] for _ in range(3*n)]
for u, v in uv:
u, v = u-1, v-1
alist[u].append(n+v)
alist[n+u].append(2*n+v)
alist[2*n+u].append(v)
# BFS
queue = [s-1]
visited = [-3]*(3*n)
visited[s-1] = 0
while len(queue) > 0:
q = queue.pop(0)
for v in alist[q]:
if visited[v] < 0:
queue.append(v)
visited[v] = visited[q] + 1
print((visited[t-1]//3))
| p02991 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
def f(D, S, T):
close = [[False] * N, [False] * N, [False] * N]
Q = []
index = 0
Q.append((S, 0, 0))
while len(Q) > index:
p, c, l = Q[index]
index += 1
if l == 0 and p == T:
return c
close[l][p] = True
l, c = (l + 1) % 3, c + (l + 1) // 3
for n in D[p]:
if close[l][n]:
continue
Q.append((n, c, l))
return -1
if __name__ == "__main__":
D = {n: set() for n in range(N)}
for m in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
D[u].add(v)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
print((f(D, S, T)))
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
def f(D, S, T):
close = [[False] * N, [False] * N, [False] * N]
Q = []
index = 0
Q.append((S, 0, 0))
while len(Q) > index:
p, c, l = Q[index]
index += 1
if close[l][p]:
continue
if l == 0 and p == T:
return c // 3
close[l][p] = True
l, c = (l + 1) % 3, c + 1
for n in D[p]:
if close[l][n]:
continue
Q.append((n, c, l))
return -1
if __name__ == "__main__":
D = {n: set() for n in range(N)}
for m in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
D[u].add(v)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
print((f(D, S, T)))
| p02991 |
import queue
def dist(s, t, g):
q = queue.Queue()
dists = [-1]*len(g)
dists[s] = 0
q.put(s)
f = False
while not q.empty():
target = q.get()
for v in g[target]:
if dists[v] == -1:
dists[v] = dists[target] + 1
if v == t:
f = True
break
q.put(v)
if f:
break
return dists[t]
def main():
n, m = list(map(int, input().split()))
g = [[] for _ in range(n*3)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
g[u].append(v+n)
g[u+n].append(v+2*n)
g[u+2*n].append(v)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
print((dist(s, t, g)//3))
if __name__ == "__main__":
main() | def dist(s, t, g):
q = [s]
dists = [-1]*len(g)
dists[s] = 0
while len(q) != 0:
p = []
for u in q:
for v in g[u]:
if dists[v] != -1:
continue
p.append(v)
dists[v] = dists[u] + 1
q = p
return dists[t]
def main():
n, m = list(map(int, input().split()))
g = [[] for _ in range(n*3)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
g[u].append(v+n)
g[u+n].append(v+2*n)
g[u+2*n].append(v)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
print((dist(s, t, g)//3))
if __name__ == "__main__":
main()
| p02991 |
import heapq
N, M = list(map(int, input().split()))
Edge = [list(map(int, input().split())) for i in range(M)]
S, T = list(map(int, input().split()))
S, T = S - 1, T - 1
G3 = [[] for i in range(3 * N)]
for u, v in Edge:
u, v = u - 1, v - 1
G3[u].append([v + N, 1])
G3[u + N].append([v + N * 2, 1])
G3[u + 2 * N].append([v, 1])
def dijkstra(x):
d = [float('inf')] * (3 * N)
d[x] = 0
visited = {x}
# d, u
hq = [(0, x)]
while hq:
u = heapq.heappop(hq)[1]
visited.add(u)
for node, cost in G3[u]:
if (node not in visited) and d[node] > d[u] + cost:
d[node] = d[u] + cost
heapq.heappush(hq, (d[u] + cost, node))
return d
dist = dijkstra(S)
print((dist[T] // 3 if dist[T] != float('inf') else - 1))
| N, M = list(map(int, input().split()))
G = [[] for i in range(3 * N)]
for i in range(M):
u, v = list(map(int, input().split()))
u, v = u - 1, v - 1
G[u].append([v + N, 1])
G[u + N].append([v + 2 * N, 1])
G[u + 2 * N].append([v, 1])
S, T = list(map(int, input().split()))
S, T = S - 1, T - 1
def dijkstra(graph, start, inf=float('inf')):
import heapq
n = len(graph)
distances = [inf] * n
distances[start] = 0
visited = [False] * n
# 距離・頂点
hq = [(0, start)]
while hq:
dist, fr = heapq.heappop(hq)
visited[fr] = True
for to, cost in graph[fr]:
new_dist = distances[fr] + cost
if (visited[to]) or (distances[to] <= new_dist):
continue
distances[to] = new_dist
heapq.heappush(hq, (new_dist, to))
return distances
distances = dijkstra(G, S)
print((distances[T] // 3 if distances[T] != float('inf') else -1))
| p02991 |
from collections import deque
N,M,*f = list(map(int, open(0).read().split()))
uv = [f[i:i+2] for i in range(0, len(f)-2, 2)]
S = f[-2]
T = f[-1]
connected = [[] for _ in range(N+1)]
for u, v in uv:
connected[u].append(v)
d = deque([S])
for i in range(1,N+1):
for j in range(3):
for k in range(len(d)):
temp = d.popleft()
for edge in connected[temp]:
if edge == T:
if j == 2:
print(i)
exit()
else:
d.append(edge)
else:
d.append(edge)
else:
print('-1') | from collections import deque
N,M,*f = list(map(int, open(0).read().split()))
uv = [f[i:i+2] for i in range(0, len(f)-2, 2)]
S = f[-2]
T = f[-1]
connected = [[] for _ in range(N+1)]
for u, v in uv:
connected[u].append(v)
dist = [[-1] * 3 for _ in range(N+1)]
dist[S][0] = 0
ans = 0
d = deque([(S,0)])
while d:
temp = d.popleft()
for edge in connected[temp[0]]:
if edge == T and temp[1] == 2:
print(((dist[temp[0]][2]+1)//3))
break
else:
if dist[edge][(temp[1]+1)%3] < 0:
dist[edge][(temp[1]+1)%3] = dist[temp[0]][temp[1]] + 1
d.append((edge,(temp[1]+1)%3))
else:
continue
break
else:
print((-1)) | p02991 |
N, M = list(map(int, input().split()))
graph = [[] for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
graph[u].append(v)
S, T = list(map(int, input().split()))
S, T = S-1, T-1
new1 = [[] for i in range(N)]
new2 = [[] for i in range(N)]
new3 = [[] for i in range(N)]
for i in range(N):
for v in graph[i]:
new1[i].append(v)
for i in range(N):
for v in graph[i]:
new2[i].extend(new1[v])
for i in range(N):
for v in graph[i]:
new3[i].extend(new2[v])
#print(new1)
#print(new2)
#print(new3)
visit = [False for i in range(N)]
length = [0 for i in range(N)]
def bfs(v, T):
Q = []
Q.append(v)
visit[v] = True
while len(Q) > 0:
v = Q.pop(0)
#print(con)
con = list(set(new3[v]))
for u in con:
if not visit[u]:
visit[u] = True
length[u] = length[v] + 1
Q.append(u)
#print(u, length[u])
if u == T:
return()
bfs(S,T)
#print(length)
if visit[T]:
print((length[T]))
else:
print((-1))
| N, M = list(map(int, input().split()))
graph = [[] for i in range(3 * N)]
for i in range(M):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
graph[u].append(v+N)
graph[u+N].append(v+2*N)
graph[u+2*N].append(v)
S, T = list(map(int,input().split()))
S, T = S-1, T-1
visit = [False for i in range(3 * N)]
length = [0 for i in range(3 * N)]
def bfs(v):
Q = []
Q.append(v)
visit[v] = True
while Q:
v = Q.pop(0)
for u in graph[v]:
if not visit[u]:
visit[u] = True
length[u] = length[v] + 1
Q.append(u)
#print(u, length[u])
bfs(S)
#print(length)
if visit[T]:
print((int(length[T] //3)))
else:
print((-1))
| p02991 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,M,*UV,S,T = list(map(int,read().split()))
it = iter(UV)
graph = [[] for _ in range(1+N+N+N)]
for x,y in zip(it,it):
x1=x+N; x2=x1+N
y1=y+N; y2=y1+N
graph[x].append(y1)
graph[x1].append(y2)
graph[x2].append(y)
INF = 10**15
dist = [INF] * (N+N+N+1)
dist[S] = 0
q = [S]
while q:
qq = []
for x in q:
for y in graph[x]:
if dist[y] != INF:
continue
qq.append(y)
dist[y] = dist[x] + 1
q = qq
d = dist[T]
answer = -1 if d == INF else d//3
print(answer)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,M,*UV,S,T = list(map(int,read().split()))
it = iter(UV)
graph = [[] for _ in range(1+N+N+N)]
for x,y in zip(it,it):
x1=x+N; x2=x1+N
y1=y+N; y2=y1+N
graph[x].append(y1)
graph[x1].append(y2)
graph[x2].append(y)
INF = 10**15
dist = [INF] * (N+N+N+1)
dist[S] = 0
q = [S]
while q:
qq = []
for x in q:
for y in graph[x]:
if dist[y] != INF:
continue
qq.append(y)
dist[y] = dist[x] + 1
if y == T:
break
q = qq
d = dist[T]
answer = -1 if d == INF else d//3
print(answer)
| p02991 |
import queue
WHITE = 0
GRAY = 1
BLACK = 2
INFTY = 10**16
def dijkstra(s, V):
color = [WHITE for i in range(N+1)]
d = [INFTY for i in range(N+1)]
d[s] = 0
q = queue.Queue()
q.put(s)
while not q.empty():
u = q.get()
color[u] = BLACK
for v in V[u]:
if color[v] != BLACK and d[v] == INFTY:
d[v] = d[u] + 1
q.put(v)
return d
def rec(s, i, depth):
if depth == 3:
kkpgraph[s].append(i)
return
if not graph[i]:
return
for node in graph[i]:
rec(s, node, depth+1)
return
N, M = list(map(int, input().split()))
graph = [[] for i in range(N+1)]
kkpgraph = [[] for i in range(N+1)]
for i in range(M):
u, v = list(map(int, input().split()))
graph[u].append(v)
S, T = list(map(int, input().split()))
for i in range(1, N+1):
rec(i, i, 0)
d = dijkstra(S, kkpgraph)
if d[T] == INFTY:
print((-1))
else:
print((d[T]))
| import queue
WHITE = 0
GRAY = 1
BLACK = 2
INFTY = 10**16
def bfs(s, V):
color = [[WHITE for i in range(N+1)] for j in range(3)]
d = [[INFTY for i in range(N+1)] for j in range(3)]
d[0][s] = 0
q = queue.Queue()
q.put((0, s))
while not q.empty():
dv, u = q.get()
color[dv%3][u] = BLACK
for v in V[u]:
if color[(dv+1)%3][v] != BLACK and d[(dv+1)%3][v] == INFTY:
d[(dv+1)%3][v] = d[dv%3][u] + 1
q.put((d[(dv+1)%3][v], v))
return d
N, M = list(map(int, input().split()))
graph = [[] for i in range(N+1)]
for i in range(M):
u, v = list(map(int, input().split()))
graph[u].append(v)
S, T = list(map(int, input().split()))
d = bfs(S, graph)
if d[0][T] == INFTY:
print((-1))
else:
print((d[0][T]//3))
| p02991 |
n,m = list(map(int,input().split()))
uv = [[] for _ in range(n)]
for i in range(m):
u,v = [int(x)-1 for x in input().split()]
uv[u].append(v)
s,t = [int(x)-1 for x in input().split()]
time = 0
now = {s}
flag = 0
for _ in range(n):
time += 1
tmp = set()
for x in now:
for y in uv[x]:
tmp.add(y)
now = tmp
time += 1
tmp = set()
for x in now:
for y in uv[x]:
tmp.add(y)
now = tmp
time += 1
tmp = set()
for x in now:
for y in uv[x]:
tmp.add(y)
now = tmp
if t in now:
flag = 1
break
if flag == 1:
print((time//3))
else:
print((-1)) | n,m = list(map(int,input().split()))
pst = [[] for _ in range(n)]
for _ in range(m):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
pst[a].append(b)
s,t = list(map(int,input().split()))
s -= 1
t -= 1
cnt = [[0,0,0] for _ in range(n)]
cnt[s][0] = 1
now = [s]
time = 0
while now:
time += 1
last = now
now = []
for x in last:
for y in pst[x]:
if cnt[y][time%3] == 0:
cnt[y][time%3] = 1
now.append(y)
#print(time,cnt,now)
if cnt[t][0] == 1:
print((time//3))
break
else:
print((-1)) | p02991 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
# 双方向グラフで幅優先探索
from collections import deque
n, m = list(map(int, input().split()))
g = [set([]) for _ in range(n)]
#隣接リストの作成
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].add(b)
graph = [set([]) for _ in range(n)]
for i in range(n):
g1 = set([])
g2 = set([])
g3 = set([])
g1 = g1 | g[i]
for x in g1:
g2 = g2 | g[x]
for x in g2:
g3 = g3 | g[x]
graph[i] = g3
s, t = list(map(int, input().split()))
s, t = s-1, t-1
#幅優先探索
q = deque()
level = [-1]*n
q.append(s)
level[s] = 0
while len(q)>0:
cur = q.popleft()
lvl = level[cur]
for i in graph[cur]:
if level[i]==-1:
#階層
level[i] = lvl + 1
q.append(i)
print((level[t]))
| #!/usr/bin python3
# -*- coding: utf-8 -*-
# 双方向グラフで幅優先探索
from collections import deque
n, m = list(map(int, input().split()))
g = [set([]) for _ in range(n)]
#隣接リストの作成
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].add(b)
s, t = list(map(int, input().split()))
s, t = s-1, t-1
#幅優先探索
q = deque()
level = [[-1]*n for i in range(3)]
q.append((s, 0))
level[0][s] = 0
while len(q)>0:
cur, hp = q.popleft()
lvl = level[hp][cur]
for i in g[cur]:
if level[(hp+1)%3][i]==-1:
#階層
level[(hp+1)%3][i] = lvl + 1
q.append((i, (hp+1)%3))
print((level[0][t]//3))
| p02991 |
import queue
INF=-1
N,M=[int(e) for e in input().split(' ')]
to=[[] for _ in range(N)]
for i in range(M):
u,v=[int(e) for e in input().split(' ')]
to[u-1].append(v-1)
S,T=[int(e)-1 for e in input().split(' ')]
dist=[[INF for i in range(3)] for j in range(N)]
q=queue.Queue()
q.put([S,0])
dist[S][0]=0
while(not q.empty()):
v,l=q.get()
for v_to in to[v]:
nl=(l+1)%3
if dist[v_to][nl] != INF:
continue
dist[v_to][nl]=dist[v][l]+1
q.put([v_to,nl])
ans=dist[T][0]
if ans == INF:
ans = -1
else:
ans=ans//3
print(ans)
| #import queue
from collections import deque
INF=-1
N,M=[int(e) for e in input().split(' ')]
to=[[] for _ in range(N)]
for i in range(M):
u,v=[int(e) for e in input().split(' ')]
to[u-1].append(v-1)
S,T=[int(e)-1 for e in input().split(' ')]
dist=[[INF for i in range(3)] for j in range(N)]
q=deque([])
q.append([S,0])
dist[S][0]=0
while(q):
v,l=q.popleft()
for v_to in to[v]:
nl=(l+1)%3
if dist[v_to][nl] != INF:
continue
dist[v_to][nl]=dist[v][l]+1
q.append([v_to,nl])
ans=dist[T][0]
if ans == INF:
ans = -1
else:
ans=ans//3
print(ans)
| p02991 |
from collections import deque
def sol():
n,m=list(map(int,input().split()))
d={}
for i in range(m):
u,v=list(map(int,input().split()))
if u in d:
d[u].append(v)
else:
d[u]=[v]
s,t=list(map(int,input().split()))
ans=chk=0
w=deque([0,s])
tmp=[0]*(n+1)
ans=1
n+=n//2
n*=2
while n:
x=w.pop()
if x==0:
ans+=1
n-=1
w.appendleft(0)
elif x in d:
for j in d[x]:
if tmp[j]==0 or tmp[j]%3!=ans%3:
w.appendleft(j)
tmp[j]=ans
if ans%3==0 and tmp[t]==ans:
print((ans//3))
exit()
print((-1))
if __name__=="__main__":
sol()
| from collections import deque
def sol():
n,m=list(map(int,input().split()))
d={}
for i in range(m):
u,v=list(map(int,input().split()))
if u in d:
d[u].append(v)
else:
d[u]=[v]
s,t=list(map(int,input().split()))
ans=chk=0
w=deque([0,s])
#tmp=[0]*(n+1)
tmp=[[0,0,0] for i in range(n+1)]
ans=1
n+=n//2
n*=2
while n:
x=w.pop()
if x==0:
ans+=1
n-=1
w.appendleft(0)
elif x in d:
for j in d[x]:
if ans%3==0 and j==t:
print((ans//3))
exit()
if tmp[j][ans%3]==0:
w.appendleft(j)
tmp[j][ans%3]=1
print((-1))
if __name__=="__main__":
sol()
| p02991 |
from collections import deque
import sys
input = sys.stdin.readline
def sol():
n,m=list(map(int,input().split()))
d={}
for i in range(m):
u,v=list(map(int,input().split()))
if u in d:
d[u].append(v)
else:
d[u]=[v]
s,t=list(map(int,input().split()))
ans=chk=0
w=deque([0,s])
tmp=[0]*(n+1)
ans=1
n+=n//2
n*=2
while n:
x=w.pop()
if x==0:
ans+=1
n-=1
w.appendleft(0)
elif x in d:
for j in d[x]:
if tmp[j]==0 or tmp[j]%3!=ans%3:
w.appendleft(j)
tmp[j]=ans
if ans%3==0 and tmp[t]==ans:
print((ans//3))
exit()
print((-1))
if __name__=="__main__":
sol() | from collections import deque
import sys
input = sys.stdin.readline
def sol():
n,m=list(map(int,input().split()))
d={}
for i in range(m):
u,v=list(map(int,input().split()))
if u in d:
d[u].append(v)
else:
d[u]=[v]
s,t=list(map(int,input().split()))
ans=0
w=deque([0,s])
tmp=[[0,0,0] for i in range(n+1)]
ans=1
n*=3
while n:
x=w.pop()
if x==0:
ans+=1
n-=1
w.appendleft(0)
elif x in d:
for j in d[x]:
if ans%3==0 and j==t:
print((ans//3))
exit()
if tmp[j][ans%3]==0:
w.appendleft(j)
tmp[j][ans%3]=1
print((-1))
if __name__=="__main__":
sol() | p02991 |
from collections import deque
import sys
input = sys.stdin.readline
def MI():return list(map(int,input().split()))
def main():
n,m=MI()
G=[[] for _ in range(n)]
for _ in range(m):
u,v=MI()
u-=1
v-=1
G[u].append(v)
s,t=MI()
s-=1
t-=1
fi=[True]*n
se=[True]*n
th=[True]*n
th[s]=False
dq=deque([])
dq.append(s)
depth=0
while dq:
depth+=1
tank1=[]
tank2=[]
tank3=[]
for p in dq:
for c in G[p]:
if fi[c]:
fi[c]=False
tank2.append(c)
for p in tank2:
for c in G[p]:
if se[c]:
se[c]=False
tank3.append(c)
for p in tank3:
for c in G[p]:
if th[c]:
th[c]=False
tank1.append(c)
if c==t:
print(depth)
exit()
dq=deque(tank1)
print((-1))
if __name__=='__main__':
main()
| #from collections import deque
import sys
input = sys.stdin.readline
def MI():return list(map(int,input().split()))
def main():
n,m=MI()
G=[[] for _ in range(n)]
for _ in range(m):
u,v=MI()
u-=1
v-=1
G[u].append(v)
s,t=MI()
s-=1
t-=1
fi=[True]*n
se=[True]*n
th=[True]*n
th[s]=False
#dq=deque([])
#dq.append(s)
dq=[s]
depth=0
while dq:
depth+=1
tank1=[]
tank2=[]
tank3=[]
for p in dq:
for c in G[p]:
if fi[c]:
fi[c]=False
tank2.append(c)
for p in tank2:
for c in G[p]:
if se[c]:
se[c]=False
tank3.append(c)
for p in tank3:
for c in G[p]:
if th[c]:
th[c]=False
tank1.append(c)
if c==t:
print(depth)
exit()
dq=tank1
print((-1))
if __name__=='__main__':
main()
| p02991 |
import sys
#色々とメモリ使用量には気をつける
from collections import deque
n, m=list(map(int, input().split()))
u_list=[]
v_list=[]
for i in range(m):
u, v=list(map(int, input().split()))
u_list.append(u)
v_list.append(v)
s, t=list(map(int, input().split()))
queue=deque()
kenken=[]
for i in range(1, n+1):
queue.append((i, 0))
while(len(queue))!=0:
target=queue.popleft()
target_pos=target[0]
target_val=target[1]
for j in range(m):
if u_list[j]==target_pos:
if target_val+1==3:
kenken.append((i, v_list[j]))
else:
queue.append((v_list[j], target_val+1))
use_edge=[1 for i in range(len(kenken))]
queue.append((s, 0))
while(len(queue)!=0):
target=queue.popleft()
target_pos=target[0]
target_val=target[1]
for j in range(m):
if use_edge[j]:
if kenken[j][0]==target_pos:
if kenken[j][1]==t:
print((target_val+1))
sys.exit()
else:
queue.append((kenken[j][1], target_val+1))
use_edge[j]=0
print((-1))
| import sys
from collections import deque
n, m=list(map(int,input().split()))
"""
頂点1~nを1~3nに3倍加する
"""
edges=[[] for i in range(3*n)]
for i in range(m):
"""
uからvへの枝を
uからv+n, u+nからv+2n, u+2nからv+3n
とする
(枝を3倍加)
"""
u, v=list(map(int, input().split()))
u, v=u-1, v-1
edges[u].append(v+n)
edges[u+n].append(v+2*n)
edges[u+2*n].append(v)
s, t=list(map(int, input().split()))
s, t=s-1, t-1
q=deque()
q.append(s)
dist=[-1]*(3*n)
dist[s]=0
"""
結局求めるものは，s~tへの最短距離を3で割ったもの
"""
while len(q)!=0:
fr=q.popleft()
for to in edges[fr]:
#もし行ったことがなければ
if dist[to]==-1:
dist[to]=dist[fr]+1
q.append(to)
print((dist[t]//3))
| p02991 |
#132_E
import queue
import sys
sys.setrecursionlimit(300000)
n,m=list(map(int,input().split()))
edges=[[] for i in range(n)]
for _ in range(m):
u,v=list(map(int,input().split()))
edges[u-1].append(v-1)
edges_3=[[] for i in range(n)]
for i in range(n):
for x in edges[i]:
for y in edges[x]:
for z in edges[y]:
edges_3[i].append(z)
s,t=list(map(int,input().split()))
s,t=s-1,t-1
def bfs(s,t):
que=queue.Queue()
que.put(s)
d[s]=0
visit[s]=True
while not que.empty():
q=que.get()
if q==t:
return d[t]
for z in edges_3[q]:
if visit[z]==False:
que.put(z)
d[z]=d[q]+1
visit[z]=True
return d[t]
visit=[False for _ in range(n)]
d=[-1 for _ in range(n)]
print((bfs(s,t))) | #### 132_E
import queue
import sys
sys.setrecursionlimit(300000)
n,m=list(map(int,input().split()))
edges=[[] for i in range(3*n)]
for _ in range(m):
u,v=list(map(int,input().split()))
u,v=u-1,v-1
u0,u1,u2=u,u+n,u+2*n
v0,v1,v2=v,v+n,v+2*n
edges[u0].append(v1)
edges[u1].append(v2)
edges[u2].append(v0)
s,t=list(map(int,input().split()))
s,t=s-1,t-1
def bfs(s,t):
que=queue.Queue()
que.put(s)
d[s]=0
visit[s]=True
while not que.empty():
q=que.get()
if q==t:
return d[t]
for z in edges[q]:
if visit[z]==False:
que.put(z)
d[z]=d[q]+1
visit[z]=True
return d[t]
visit=[False for _ in range(3*n)]
d=[-1 for _ in range(3*n)]
print((bfs(s,t)//3)) | p02991 |
from collections import defaultdict as dd
from collections import deque
from copy import deepcopy as dc
N, M = list(map(int, input().split()))
e = dd(list)
inf = 10 ** 9
for _ in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
S, T = list(map(int, input().split()))
stopped = [inf] * (N + 1)
Q = deque()
Q.append(S)
stopped[S] = 0
saw2 = {i: 0 for i in range(1, N + 1)}
#saw3 = {i: 0 for i in range(1, N + 1)}
while len(Q) != 0:
s2 = dc(saw2)
#s3 = dc(saw3)
p = Q.popleft()
if stopped[p] >= stopped[T]:
break
for q in e[p]:
for r in e[q]:
if s2[r] == 1:
continue
else:
s2[r] = 1
for s in e[r]:
#if s3[s] == 1:
# continue
#else:
# s3[s] = 1
if stopped[s] > stopped[p] + 1:
Q.append(s)
stopped[s] = stopped[p] + 1
if stopped[T] == inf:
print((-1))
else:
print((stopped[T])) | from collections import defaultdict as dd
from collections import deque
N, M = list(map(int, input().split()))
e = dd(list)
inf = 10 ** 9
for _ in range(M):
u, v = list(map(int, input().split()))
e[u].append(v + N)
e[u + N].append(v + 2 * N)
e[u + 2 * N].append(v)
S, T = list(map(int, input().split()))
S += 2 * N
T += 2 * N
stopped = [inf] * (3 * (N + 1))
Q = deque()
Q.append(S)
stopped[S] = 0
while len(Q) != 0:
p = Q.popleft()
if stopped[p] >= stopped[T]:
break
for q in e[p]:
if stopped[q] > stopped[p] + 1:
Q.append(q)
stopped[q] = stopped[p] + 1
if stopped[T] == inf:
print((-1))
else:
print((stopped[T] // 3)) | p02991 |
from collections import deque
n,m = list(map(int,input().split()))
path = [[set() for _ in range(n)] for _ in range(3)]
for _ in range(m):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
path[0][u].add(v)
s,t = list(map(int,input().split()))
for i in range(2):
for j in range(n):
for k in path[i][j]:
path[i+1][j] = path[i+1][j] | path[0][k]
que = deque([s-1])
d = [float('inf')]*n
d[s-1] = 0
while que:
p = que.popleft()
for to in path[2][p]:
if d[to] == float('inf'):
d[to] = d[p] + 1
que.append(to)
if d[t-1] == float('inf'):
d[t-1] = -1
print((d[t-1]))
| from collections import deque
n,m = list(map(int,input().split()))
path = [set() for _ in range(n)]
for _ in range(m):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
path[u].add(v)
s,t = list(map(int,input().split()))
que = deque([(s-1,0)])
d = [[float('inf')]*n for _ in range(3)]
d[0][s-1] = 0
while que:
p,i = que.popleft()
j = (i+1)%3
for to in path[p]:
if d[j][to] == float('inf'):
d[j][to] = d[i][p] + 1
que.append((to,j))
if d[0][t-1] == float('inf'):
d[0][t-1] = -3
print((d[0][t-1]//3))
| p02991 |
from collections import deque
def main():
N, M = list(map(int, input().split()))
dp = [[set() for _ in range(N)] for _ in range(3)]
for _ in range(M):
u, v = list(map(int, input().split()))
dp[0][v-1].add(u-1)
S, T = list(map(int, input().split()))
for i in range(1, 3):
for j in range(N):
tmp = set()
for nxt in dp[i-1][j]:
tmp = tmp.union(dp[0][nxt])
dp[i][j] = tmp
adj = [set() for _ in range(N)]
for i in range(N):
for j in dp[2][i]:
adj[j].add(i)
searchq = deque()
visited = set()
searchq.append((S-1, 0))
visited.add(S-1)
while len(searchq):
p, cost = searchq.popleft()
if p == T-1:
print(cost)
return
for nxt in adj[p]:
if nxt not in visited:
searchq.append((nxt, cost+1))
visited.add(nxt)
print((-1))
if __name__ == "__main__":
main()
| from collections import deque
def main():
N, M = list(map(int, input().split()))
dp = [[[] for _ in range(N)] for _ in range(3)]
for _ in range(M):
u, v = list(map(int, input().split()))
dp[0][v-1].append(u-1)
S, T = list(map(int, input().split()))
for i in range(1, 3):
for j in range(N):
tmp = list()
for nxt in dp[i-1][j]:
tmp += dp[0][nxt]
dp[i][j] = set(tmp)
adj = [set() for _ in range(N)]
for i in range(N):
for j in dp[2][i]:
adj[j].add(i)
searchq = deque()
visited = set()
searchq.append((S-1, 0))
visited.add(S-1)
while len(searchq):
p, cost = searchq.popleft()
if p == T-1:
print(cost)
return
for nxt in adj[p]:
if nxt not in visited:
searchq.append((nxt, cost+1))
visited.add(nxt)
print((-1))
if __name__ == "__main__":
main()
| p02991 |
from collections import deque
def main():
N, M = list(map(int, input().split()))
dp = [[[] for _ in range(N)] for _ in range(3)]
for _ in range(M):
u, v = list(map(int, input().split()))
dp[0][v-1].append(u-1)
S, T = list(map(int, input().split()))
for i in range(1, 3):
for j in range(N):
tmp = list()
for nxt in dp[i-1][j]:
tmp += dp[0][nxt]
dp[i][j] = set(tmp)
adj = [set() for _ in range(N)]
for i in range(N):
for j in dp[2][i]:
adj[j].add(i)
searchq = deque()
visited = set()
searchq.append((S-1, 0))
visited.add(S-1)
while len(searchq):
p, cost = searchq.popleft()
if p == T-1:
print(cost)
return
for nxt in adj[p]:
if nxt not in visited:
searchq.append((nxt, cost+1))
visited.add(nxt)
print((-1))
if __name__ == "__main__":
main()
| from collections import deque
def main():
N, M = list(map(int, input().split()))
dp = [[[] for _ in range(N)] for _ in range(3)]
for _ in range(M):
u, v = list(map(int, input().split()))
dp[0][v-1].append(u-1)
S, T = list(map(int, input().split()))
for i in range(1, 3):
for j in range(N):
tmp = list()
for nxt in dp[i-1][j]:
tmp += dp[0][nxt]
if len(tmp):
dp[i][j] = list(set(tmp))
adj = [set() for _ in range(N)]
for i in range(N):
for j in dp[2][i]:
adj[j].add(i)
searchq = deque()
visited = set()
searchq.append((S-1, 0))
visited.add(S-1)
while len(searchq):
p, cost = searchq.popleft()
if p == T-1:
print(cost)
return
for nxt in adj[p]:
if nxt not in visited:
searchq.append((nxt, cost+1))
visited.add(nxt)
print((-1))
if __name__ == "__main__":
main()
| p02991 |
from collections import deque
def main():
N, M = list(map(int, input().split()))
dp = [[[] for _ in range(N)] for _ in range(3)]
for _ in range(M):
u, v = list(map(int, input().split()))
dp[0][v-1].append(u-1)
S, T = list(map(int, input().split()))
for i in range(1, 3):
for j in range(N):
tmp = list()
for nxt in dp[i-1][j]:
tmp += dp[0][nxt]
if len(tmp):
dp[i][j] = list(set(tmp))
adj = [set() for _ in range(N)]
for i in range(N):
for j in dp[2][i]:
adj[j].add(i)
searchq = deque()
visited = set()
searchq.append((S-1, 0))
visited.add(S-1)
while len(searchq):
p, cost = searchq.popleft()
if p == T-1:
print(cost)
return
for nxt in adj[p]:
if nxt not in visited:
searchq.append((nxt, cost+1))
visited.add(nxt)
print((-1))
if __name__ == "__main__":
main()
| from collections import deque
def main():
N, M = list(map(int, input().split()))
adj = [set() for _ in range(N*3)]
dp = [[[] for _ in range(N)] for _ in range(3)]
for _ in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
adj[u].add(N*1+v)
adj[N*1+u].add(N*2+v)
adj[N*2+u].add(v)
S, T = list(map(int, input().split()))
searchq = deque()
visited = set()
searchq.append((S-1, 0))
visited.add(S-1)
while len(searchq):
p, cost = searchq.popleft()
if p == T-1:
print((cost//3))
return
for nxt in adj[p]:
if nxt not in visited:
searchq.append((nxt, cost+1))
visited.add(nxt)
print((-1))
if __name__ == "__main__":
main()
| p02991 |
def main():
N, M = list(map(int, input().split()))
INF = 2**30-1
mat = [[INF for _ in range(3*N)] for _ in range(3*N)]
for _ in range(M):
u, v = list(map(int, input().split()))
mat[u-1][N+v-1] = 1
mat[N+u-1][2*N+v-1] = 1
mat[2*N+u-1][v-1] = 1
for i in range(3*N):
for j in range(3*N):
for k in range(3*N):
mat[j][k] = min(mat[j][k], mat[j][i]+mat[i][k])
S, T = list(map(int, input().split()))
if mat[S-1][T-1] == INF:
print((-1))
else:
print((mat[S-1][T-1]//3))
if __name__ == '__main__':
main() | def main():
N, M = list(map(int, input().split()))
INF = 2**30-1
mat = [[] for _ in range(3*N)]
for _ in range(M):
u, v = list(map(int, input().split()))
mat[u-1].append([N+v-1, 1])
mat[N+u-1].append([2*N+v-1, 1])
mat[2*N+u-1].append([v-1, 1])
S, T = list(map(int, input().split()))
queue = list(mat[S-1])
visited = [False]*(3*N)
visited[S-1] = True
while queue:
pos, d = queue.pop()
if pos == T-1:
print((d//3))
return
visited[pos] = True
next_positions = mat[pos]
for next_pos, next_d in next_positions:
if visited[next_pos]:
continue
queue.append([next_pos, d+next_d])
queue.sort(key=lambda x: x[1])
print((-1))
if __name__ == '__main__':
main() | p02991 |
# https://atcoder.jp/contests/abc132/tasks/abc132_e
# ぱっと思いつくのはダイクストラで3回で到達できる点を探索していくとかかなぁ
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina(*argv, sub=1): return list([x - sub for x in argv])
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def read_a_int(): return int(read())
def read_ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
from heapq import heapify, heappop, heappush, heappushpop
def bfs(graph, s, N):
'''
graph...隣接リスト形式 リスト内要素はノード
s...始点ノード
N...頂点数
return
----------
D ... 各点までの最短距離
'''
# pq = PriorityQueue([])
cnt = 0
pq = deque([])
D = [2**31] * N
D[s] = 0
is_visited = [False] * N
is_visited[s] = True
pq.append((D[s], s)) # (最短距離, 次のノード)
while pq:
d, v = pq.popleft()
# 探索するのはgraph[v]じゃなくてケンケンパしてたどり着くことのできるノード
for to in next_node(v, graph):
cnt += 1
assert cnt < 10**7 # 10**7じゃなくてもTLEになっている...
if is_visited[to]:
continue
cost = 1
D[to] = d + cost
is_visited[to] = True
pq.append((D[to], to))
return D
def next_node(v, graph):
# 距離3のノードの集合を集めてくる
ret = set()
q = deque([(0, v)])
while q:
d, u = q.popleft()
if d == 3:
ret.add(u)
continue
for to in graph[u]:
q.append((d + 1, to))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
N, M = read_ints()
graph = defaultdict(lambda: [])
for _ in range(M):
u, v = mina(*read_ints())
graph[u].append(v)
S, T = mina(*read_ints())
# D = bfs(graph, S, N)
s = S
cnt = 0
pq = deque([])
D = [2**31] * N
D[s] = 0
is_visited = [False] * N
is_visited[s] = True
pq.append((D[s], s)) # (最短距離, 次のノード)
while pq:
d, v = pq.popleft()
# 探索するのはgraph[v]じゃなくてケンケンパしてたどり着くことのできるノード
for to in next_node(v, graph):
cnt += 1
assert cnt < 10**7 # 10**7じゃなくてもTLEになっている...
if is_visited[to]:
continue
cost = 1
D[to] = d + cost
is_visited[to] = True
pq.append((D[to], to))
print((D[T] if D[T] != INF else -1))
| # https://atcoder.jp/contests/abc132/tasks/abc132_e
# ぱっと思いつくのはダイクストラで3回で到達できる点を探索していくとかかなぁ
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina(*argv, sub=1): return list([x - sub for x in argv])
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def read_a_int(): return int(read())
def read_ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# 距離を3で割ったときに0,1,2余る場合について各ノードの最短距離を求めればよい
N, M = read_ints()
graph = defaultdict(lambda: [])
for _ in range(M):
u, v = mina(*read_ints())
graph[u].append(v + N)
graph[u + N].append(v + 2 * N)
graph[u + 2 * N].append(v)
S, T = mina(*read_ints())
pq = deque([])
D = [-3] * (N * 3)
D[S] = 0
pq.append((0, S)) # (最短距離, 次のノード)
while pq:
d, v = pq.popleft()
for to in graph[v]:
if D[to] != -3:
continue
D[to] = d + 1
pq.append((D[to], to))
print((D[T] // 3))
| p02991 |
from collections import deque
n, m = list(map(int, input().split()))
g = [[] for i in range(n)]
for i in range(m):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
g[u].append(v)
# print(g)
s, t = list(map(int, input().split()))
s, t = s-1, t-1
visited = [[-1]*3 for j in range(n)]
l = 0
queue = deque([[s, l]])
visited[s][l] = 0
while queue:
x, l = queue.popleft()
if [x, l] == [t, 0]:
print((visited[x][l]//3))
exit()
for x_ in g[x]:
new_x, new_l = x_, (l+1)%3
if visited[new_x][new_l] == -1:
visited[new_x][new_l] = visited[x][l]+1
queue.append([new_x, new_l])
print((visited[t][0])) | import sys
input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))
g = [[] for _ in range(3*n)]
for i in range(m):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
g[u].append(v+n)
g[u+n].append(v+2*n)
g[u+2*n].append(v)
s, t = list(map(int, input().split()))
s, t = s-1, t-1
from collections import deque
q = deque()
visit = [-1]*(3*n)
q.append(s)
visit[s] = 0
while q:
u = q.popleft()
for v in g[u]:
if visit[v] == -1:
visit[v] = visit[u]+1
q.append(v)
if visit[t] == -1:
print((-1))
else:
print((visit[t]//3))
| p02991 |
import queue
n,m = list(map(int, input().split()))
a = [[] for i in range(n)]
for i in range(m):
u,v = list(map(int, input().split()))
u-=1
v-=1
a[u].append(v)
s,t = list(map(int, input().split()))
s-=1
t-=1
inf = float('inf')
d = [[inf, inf, inf] for i in range(n)]
d[s][0]=0
q = queue.Queue()
for i in range(len(a[s])):
q.put(a[s][i])
d[a[s][i]][1]=1
while not q.empty():
p = q.get()
for i in range(len(a[p])):
r = a[p][i]
c = []
if d[r][0]==inf:
c.append(0)
if d[r][1]==inf:
c.append(1)
if d[r][2]==inf:
c.append(2)
if not c:
continue
flag = False
for j in range(len(c)):
if c[j]==0:
if d[p][2]!=inf:
break
elif c[j]==1:
if d[p][0]!=inf:
break
elif c[j]==2:
if d[p][1]!=inf:
break
if j==len(c)-1:
flag=True
if flag:
continue
q.put(r)
if d[r][0]==inf:
d[r][0]=d[p][2]+1
if d[r][1]==inf:
d[r][1]=d[p][0]+1
if d[r][2]==inf:
d[r][2]=d[p][1]+1
if r==t and d[r][0]!=inf:
print((d[r][0]//3))
exit()
print((-1))
| import queue
n,m = list(map(int, input().split()))
a = [[] for i in range(n)]
for i in range(m):
u,v = list(map(int, input().split()))
u-=1
v-=1
a[u].append(v)
s,t = list(map(int, input().split()))
s-=1
t-=1
inf = float('inf')
d = [[inf, inf, inf] for i in range(n)]
d[s][0]=0
q = queue.Queue()
for i in range(len(a[s])):
q.put(a[s][i])
d[a[s][i]][1]=1
while not q.empty():
p = q.get()
for i in range(len(a[p])):
r = a[p][i]
c = []
if d[r][0]==inf:
c.append(0)
if d[r][1]==inf:
c.append(1)
if d[r][2]==inf:
c.append(2)
if not c:
continue
flag = False
for j in range(len(c)):
if c[j]==0:
if d[p][2]!=inf:
break
elif c[j]==1:
if d[p][0]!=inf:
break
elif c[j]==2:
if d[p][1]!=inf:
break
if j==len(c)-1:
flag=True
if flag:
continue
q.put(r)
for j in range(len(c)):
if c[j]==0:
d[r][0] = d[p][2] + 1
elif c[j]==1:
d[r][1] = d[p][0] + 1
elif c[j]==2:
d[r][2] = d[p][1] + 1
if r==t and d[r][0]!=inf:
print((d[r][0]//3))
exit()
print((-1))
| p02991 |
import sys
import heapq
n, m = [int(i) for i in sys.stdin.readline().split()]
graph = [[0 for i in range(3 * n)] for j in range(3 * n)]
for i in range(m):
u, v = [int(i) for i in sys.stdin.readline().split()]
u -= 1
v -= 1
graph[u][n+v] = 1
graph[u+n][2*n+v] = 1
graph[u + 2 * n][v] = 1
s, t = [int(i) for i in sys.stdin.readline().split()]
s -= 1
t -= 1
que = [(0,s)]
already = set()
flg = False
while que:
cost, cur = heapq.heappop(que)
already.add(cur)
if cur == t:
flg = True
break
for i, _next in enumerate(graph[cur]):
if _next == 0:
continue
if i in already:
continue
heapq.heappush(que, (cost + 1, i))
if not flg:
cost = -1
else:
cost //= 3
print(cost) | import sys
import heapq
n, m = [int(i) for i in sys.stdin.readline().split()]
graph = {j:[] for j in range(3 * n)}
for i in range(m):
u, v = [int(i) for i in sys.stdin.readline().split()]
u -= 1
v -= 1
graph[u].append(n+v)
graph[u+n].append(2*n+v)
graph[u + 2 * n].append(v)
s, t = [int(i) for i in sys.stdin.readline().split()]
s -= 1
t -= 1
que = [(0,s)]
already = set()
flg = False
while que:
cost, cur = heapq.heappop(que)
already.add(cur)
if cur == t:
flg = True
break
for i in graph[cur]:
if i in already:
continue
heapq.heappush(que, (cost + 1, i))
if not flg:
cost = -1
else:
cost //= 3
print(cost) | p02991 |
import sys
from collections import deque
n, m = [int(i) for i in sys.stdin.readline().split()]
graph = {j:[] for j in range(3 * n)}
for i in range(m):
u, v = [int(i) for i in sys.stdin.readline().split()]
u -= 1
v -= 1
graph[u].append(n+v)
graph[u+n].append(2*n+v)
graph[u + 2 * n].append(v)
s, t = [int(i) for i in sys.stdin.readline().split()]
s -= 1
t -= 1
que = deque([(0, s)])
already = set()
flg = False
while que:
cost, cur = que.popleft()
already.add(cur)
if cur == t:
flg = True
break
for i in graph[cur]:
if i not in already:
que.append((cost + 1, i))
if not flg:
cost = -1
else:
cost //= 3
print(cost) | import sys
INF = 10 ** 9
n, m = [int(i) for i in sys.stdin.readline().split()]
graph = {j:[] for j in range(3 * n)}
for i in range(m):
u, v = [int(i) for i in sys.stdin.readline().split()]
u -= 1
v -= 1
graph[u].append(n+v)
graph[u+n].append(2*n+v)
graph[u + 2 * n].append(v)
s, t = [int(i) for i in sys.stdin.readline().split()]
s -= 1
t -= 1
que = [s]
flg = False
already = set()
dist = [INF for i in range(3 * n)]
dist[s] = 0
while que:
cur= que[0]
que.pop(0)
for i in graph[cur]:
if i not in already:
if i == t:
res = dist[cur] + 1
que.clear()
flg = True
break
que.append(i)
dist[i] = dist[cur] + 1
already.add(i)
if not flg:
res = -1
else:
res //= 3
print(res) | p02991 |
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
# 一次元累積和
from itertools import accumulate
from bisect import bisect_left, bisect_right
# import numpy as np
# from scipy.misc import perm
# from scipy.misc import comb
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
# 四方向: 右, 下, 左, 上
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl(): return int(eval(input()))
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")
########
class Edge:
def __init__(self, from_edge, to_edge, cost):
self.from_edge = from_edge
self.to_edge = to_edge
self.cost = cost
def bellman_ford(start, edges, node_num):
dist = [INF] * node_num
dist[start] = 0
flag = False # 負の閉路の有無
for i in range(node_num):
for edge in edges:
if dist[edge.to_edge] > dist[edge.from_edge] + edge.cost:
dist[edge.to_edge] = dist[edge.from_edge] + edge.cost
if i == N-1:
flag = True
return dist, flag
if __name__ == "__main__":
# https://atcoder.jp/contests/abc016/tasks/abc016_3
N, M = l_inpl()
edges = []
for _ in range(M):
u, v = l_inpl()
u, v = u-1, v-1
edges.append(Edge(u, v+N, 1))
edges.append(Edge(u+N, v+N*2, 1))
edges.append(Edge(u+N*2, v, 1))
S, T = l_inpl()
S, T = S-1, T-1
ans = bellman_ford(S, edges, N*3)[0][T]
if ans == INF:
print((-1))
else:
print((ans//3))
| import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
# 一次元累積和
from itertools import accumulate
from bisect import bisect_left, bisect_right
# import numpy as np
# from scipy.misc import perm
# from scipy.misc import comb
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
# 四方向: 右, 下, 左, 上
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl(): return int(eval(input()))
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")
########
if __name__ == "__main__":
N, M = l_inpl()
to = [[] for _ in range(N)]
for _ in range(M):
u, v = l_inpl()
u, v = u-1, v-1
to[u].append(v)
S, T = l_inpl()
S, T = S-1, T-1
dist = [[INF, INF, INF] for _ in range(N)]
dist[S][0] = 0
q = deque([])
q.append([S, 0])
while q:
v, l = q.popleft()
for v_to in to[v]:
nl = (l + 1) % 3
if dist[v_to][nl] != INF:
continue
dist[v_to][nl] = dist[v][l] + 1
q.append([v_to, nl])
ans = dist[T][0]
if ans == INF:
ans = -1
else:
ans = ans//3
print(ans)
| p02991 |
import queue
N,M = list(map(int, input().split()))
G = [[] for i in range(3*N+1)]
for i in range(M):
u,v = list(map(int, input().split()))
G[u].append(v+N)
G[u+N].append(v+2*N)
G[u+2*N].append(v)
S,T = list(map(int, input().split()))
def bfs(s):
que = queue.Queue()
que.put(s)
d = [-1 for _ in range(3*N+1)]
d[s] = 0
while not que.empty():
p = que.get()
if (T == p):
return d[p]
for pp in G[p]:
if d[pp] == -1:
que.put(pp)
d[pp] = d[p]+1
return -1
ans = bfs(S)
if (-1 == ans):
print((-1))
else:
print((ans//3))
| import collections
N,M = list(map(int, input().split()))
G = [[] for i in range(3*N+1)]
for i in range(M):
u,v = list(map(int, input().split()))
G[u].append(v+N)
G[u+N].append(v+2*N)
G[u+2*N].append(v)
S,T = list(map(int, input().split()))
def bfs(s):
que = collections.deque()
que.append(s)
d = [-1 for _ in range(3*N+1)]
d[s] = 0
while (0 < len(que)):
p = que.popleft()
if (T == p):
return d[p]
for pp in G[p]:
if d[pp] == -1:
que.append(pp)
d[pp] = d[p]+1
return -1
ans = bfs(S)
if (-1 == ans):
print((-1))
else:
print((ans//3)) | p02991 |
from collections import deque
def nearlist(N, LIST): # 隣接リスト
NEAR = [set() for _ in range(3 * N)]
for a, b in LIST:
a, b = 3 * (a - 1), 3 * (b - 1)
NEAR[a].add(b + 1)
NEAR[a + 1].add(b + 2)
NEAR[a + 2].add(b)
return NEAR
def bfs(S, T, N): # 幅優先探索 # キュー
S, T = 3 * (S - 1), 3 * (T - 1)
dist = [-3] * (3 * N) # 前処理
dist[S] = 0
que, flag = deque([S]), set([S])
while que:
q = que.popleft()
for i in near[q]: # 移動先の候補
if i in flag: # 処理済みか否か
continue
dist[i] = dist[q] + 1
que.append(i), flag.add(i)
return dist[T] // 3
n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
# 解説AC
near = nearlist(n, uv)
ans = bfs(s, t, n)
print(ans)
| from collections import deque
def nearlist(N, LIST): # 隣接リスト
NEAR = [set() for _ in range(3 * N)]
for a, b in LIST:
a, b = 3 * (a - 1), 3 * (b - 1)
NEAR[a].add(b + 1)
NEAR[a + 1].add(b + 2)
NEAR[a + 2].add(b)
return NEAR
def bfs(S, T, N): # 幅優先探索 # キュー
S, T = 3 * (S - 1), 3 * (T - 1)
dist, flag = [-3] * (3 * N), [0] * (3 * N) # 前処理
dist[S], flag[S], que = 0, 1, deque([S])
while que:
q = que.popleft()
for i in near[q]: # 移動先の候補
if flag[i]: # 処理済みか否か
continue
dist[i] = dist[q] + 1
flag[i] = 1
que.append(i)
return dist[T] // 3
n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
# 解説AC
near = nearlist(n, uv)
ans = bfs(s, t, n)
print(ans)
| p02991 |
from collections import deque
N, M = list(map(int, input().split()))
G = {k: [] for k in range(N+1)}
for _ in range(M):
u, v = list(map(int, input().split()))
G[u].append(v)
S, T = list(map(int, input().split()))
visited = [[10**9] * (N+1) for _ in range(3)]
que = deque([(S, 0)])
while que:
ci, t = que.popleft()
visited[t % 3][ci] = t
for ni in G[ci]:
if visited[(t+1) % 3][ni] > t+1:
que.append((ni, t+1))
if visited[0][T] == 10**9:
print((-1))
else:
print((visited[0][T]//3))
| from collections import deque
N, M = list(map(int, input().split()))
G = [[[] for j in range(3)] for i in range(N+1)]
for _ in range(M):
u, v = list(map(int, input().split()))
for i in range(3):
G[u][i].append((v, (i+1) % 3))
S, T = list(map(int, input().split()))
visited = [[-1] * 3 for _ in range(N+1)]
que = deque([(S, 0, 0)])
visited[S][0] = 0
while que:
ci, l, d = que.popleft()
for ni, nl in G[ci][l]:
if visited[ni][nl] == -1:
que.append((ni, nl, d+1))
visited[ni][nl] = d+1
print((visited[T][0]//3))
| p02991 |
from collections import deque
n,m=list(map(int,input().split()))
g=[[] for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
g[a-1].append(b-1)
gken=[[] for i in range(n)]
for i in range(n):
for j in g[i]:
for j2 in g[j]:
for j3 in g[j2]:
gken[i].append(j3)
s,t=list(map(int,input().split()))
s-=1
t-=1
q=deque([[s,0]])
v=[0]*n
while q:
p=q.popleft()
v[p[0]]=1
for j3 in gken[p[0]]:
if j3==t:
print((p[1]+1))
exit()
if v[j3]==0:
v[j3]=1
q.append([j3,p[1]+1])
print((-1))
| from collections import deque
n,m=list(map(int,input().split()))
g=[[] for i in range(3*n)]
for i in range(m):
a,b=list(map(int,input().split()))
g[3*(a-1)].append(3*(b-1)+1)
g[3*(a-1)+1].append(3*(b-1)+2)
g[3*(a-1)+2].append(3*(b-1))
s,t=list(map(int,input().split()))
s-=1
t-=1
s*=3
t*=3
q=deque([[s,0]])
v=[0]*(3*n)
while q:
p=q.popleft()
v[p[0]]=1
for j3 in g[p[0]]:
if j3==t:
print(((p[1]+1)//3))
exit()
if v[j3]==0:
v[j3]=1
q.append([j3,p[1]+1])
print((-1))
| p02991 |
from collections import deque
n,m = list(map(int,input().split()))
uv = [[] for i in range(n)]
for i in range(m):
u,v = list(map(int,input().split()))
#uv[v-1].append(u-1)
uv[u-1].append(v-1)
s,t = list(map(int,input().split()))
check = [[0 for i in range(3)] for j in range(n)]
d = deque()
d.appendleft([0,s-1])
#check[s-1][0] = 1
while len(d) > 0:
for i in range(len(d)):
num,ver = d.popleft()
check[ver][num%3] = 1
num = num+1
#cnt += 1
for j in range(len(uv[ver])):
#print(cnt,num,ver,j,t-1,uv[ver][j])
if uv[ver][j] == t-1 and num%3 == 0:
print((num//3))
exit()
if check[uv[ver][j]][num%3] == 0:
#check[uv[ver][j]][num] = 1
d.append([num,uv[ver][j]])
print((-1)) | # coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# vertexごとに3つの状態数を持つ
N, M = lr()
graph = [[] for _ in range((N+1)*3)] # 1-indexed
for _ in range(M):
a, b = lr()
a *= 3; b *= 3
for i in range(3):
j = i+1 if i < 2 else 0
graph[a+i].append(b+j)
INF = 10 ** 15
def dijkstra(start):
dist = [INF] * (N+1) * 3
dist[start] = 0
que = [(0, start)]
while que:
d, prev = heappop(que)
if dist[prev] < d:
continue
for i in graph[prev]:
#print(graph[prev],dist[next],next)
d1 = d + 1
if dist[i] > d1:
dist[i] = d1
heappush(que, (d1, i))
return dist
S, T = lr()
dist = dijkstra(S*3)
answer = dist[T*3]
if answer == INF:
answer = -1
else:
answer //= 3
print(answer)
| p02991 |
import copy
a,b=list(map(int,input().split()))
c=[list(map(int,input().split())) for i in range(b)]
s,t=list(map(int,input().split()))
s=3*s
t=3*t
dd=[[]for i in range(a+1)]
for i in range(b):
da=c[i][0]
db=c[i][1]
dd[da].append(db)
d=[[]for i in range(3*(a+1))]
for i in range(len(dd)):
for j in dd[i]:
d[3*i].append(3*j+1)
d[3*i+1].append(3*j+2)
d[3*i+2].append(3*j)
e=[s]
f=[s]
h=0
for i in range(1,3*a+3):
g=[]
for j in f:
for k in d[j]:
if k not in e:
e.append(k)
g.append(k)
if k==t:
print((i//3))
h=1
break
if h==1:
break
if h==1:
break
if g==[]:
print((-1))
break
f=copy.copy(g) | import copy
a,b=list(map(int,input().split()))
c=[list(map(int,input().split())) for i in range(b)]
s,t=list(map(int,input().split()))
s=3*s
t=3*t
dd=[[]for i in range(a+1)]
for i in range(b):
da=c[i][0]
db=c[i][1]
dd[da].append(db)
d=[[]for i in range(3*(a+1))]
for i in range(len(dd)):
for j in dd[i]:
d[3*i].append(3*j+1)
d[3*i+1].append(3*j+2)
d[3*i+2].append(3*j)
e=[-1 for i in range(3*a+3)]
f=[s]
h=0
for i in range(1,3*a+3):
g=[]
for j in f:
for k in d[j]:
if e[k]==-1:
e[k]=1
g.append(k)
if k==t:
print((i//3))
h=1
break
if h==1:
break
if h==1:
break
if g==[]:
print((-1))
break
f=copy.copy(g) | p02991 |
import sys
from heapq import heappush, heappop
inf = float('inf')
n, m = list(map(int, sys.stdin.readline().split()))
g = [[] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, sys.stdin.readline().split()))
g[u].append(v)
s, t = list(map(int, sys.stdin.readline().split()))
g2 = [[] for _ in range(n + 1)]
e = set()
hq = []
for u in range(1, n+1):
for v in g[u]:
heappush(hq, (1, u, v))
while hq:
dux = heappop(hq)
if dux in e:
continue
e.add(dux)
d, u, x = dux
if d == 3:
g2[u].append(x)
continue
for y in g[x]:
heappush(hq, (d+1, u, y))
def main():
hq = [(0, s)]
dist = [inf] * (n + 1)
while hq:
d, x = heappop(hq)
if dist[x] != inf:
continue
dist[x] = d
for y in g2[x]:
if dist[y] == inf:
heappush(hq, (d+1, y))
return dist[t] if dist[t] != inf else -1
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from heapq import heappush,heappop
inf = float('inf')
n, m = list(map(int, sys.stdin.readline().split()))
g = [[] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, sys.stdin.readline().split()))
g[u].append(v)
s, t = list(map(int, sys.stdin.readline().split()))
def main():
dist = [inf] * (n + 1)
can_reach = [[False] * 3 for _ in range(n + 1)]
hq = [(0, s)]
can_reach[s][0] = True
while hq:
d, x = heappop(hq)
if d % 3 == 0:
dist[x] = min(dist[x], d // 3)
d += 1
for y in g[x]:
if not can_reach[y][d%3]:
can_reach[y][d%3] = True
heappush(hq, (d, y))
return dist[t] if dist[t] != inf else -1
if __name__ == '__main__':
ans = main()
print(ans) | p02991 |
def BC132_E():
n, m = list(map(int, input().split(' ')))
e = [[] for _ in range(n)]
for _ in range(m):
u, v = list(map(int, input().split(' ')))
e[u - 1].append(v - 1)
s, t = list(map(int, input().split(' ')))
s, t = s - 1, t - 1
f = []
for i in range(n):
a = set()
for j in e[i]:
a.update(e[j])
b = set()
for j in list(a):
b.update(e[j])
f.append(b)
stack, visited = [(s, 0)], set()
while stack:
i, d = stack.pop(0)
if i == t: return d
if i in visited:
continue
visited.add(i)
if t in f[i]:
return d + 1
else:
stack += [(x, d + 1) for x in list(f[i])]
return -1
print((BC132_E())) | def BC132_E():
n, m = list(map(int, input().split(' ')))
e = [[] for _ in range(n)]
for _ in range(m):
u, v = list(map(int, input().split(' ')))
e[u - 1].append(v - 1)
s, t = list(map(int, input().split(' ')))
s, t = s - 1, t - 1
stack, visited = [(s, 0)], set()
a, b = set(), set()
while stack:
i, d = stack.pop(0)
if i == t: return d
if i in visited:
continue
visited.add(i)
v = set()
for j in e[i]:
if j in a: continue
a.add(j)
for k in e[j]:
if k in b: continue
b.add(k)
v.update(e[k])
if t in v:
return d + 1
else:
stack += [(x, d + 1) for x in list(v)]
return -1
print((BC132_E())) | p02991 |
# import bisect
from collections import Counter, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math
import sys
# import numpy as np
ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, m = list(map(int, ipti().split()))
node_next = [set() for _ in range(n)]
for i in range(m):
u, v = list(map(int, ipti().split()))
node_next[u-1].add(v-1)
s, t = list(map(int, ipti().split()))
s, t = s - 1, t - 1
seen = [[0] * n for _ in range(3)]
que = deque()
que.append((s, 0, 0))
while que:
cnode, cstate, dist = que.popleft()
seen[cstate][cnode] = 1
dist += 1
nstate = (cstate + 1) % 3
for nnode in node_next[cnode]:
if seen[nstate][nnode] == 0:
if nstate == 0 and nnode == t:
print((dist // 3))
sys.exit()
else:
que.append((nnode, nstate, dist))
print((-1))
if __name__ == '__main__':
main()
| # import bisect
from collections import Counter, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math
import sys
# import numpy as np
ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, m = list(map(int, ipti().split()))
node_next = [set() for _ in range(n)]
for i in range(m):
u, v = list(map(int, ipti().split()))
node_next[u - 1].add(v - 1)
s, t = list(map(int, ipti().split()))
s, t = s - 1, t - 1
dist = [[INF] * n for _ in range(3)]
dist[0][s] = 0
que = deque()
que.append((0, s))
while que:
cstate, cnode = que.popleft()
d = dist[cstate][cnode]
nstate = (cstate + 1) % 3
for nnode in node_next[cnode]:
if dist[nstate][nnode] == INF:
dist[nstate][nnode] = d + 1
que.append((nstate, nnode))
if dist[0][t] != INF:
print((dist[0][t] // 3))
else:
print((-1))
if __name__ == '__main__':
main()
| p02991 |
import heapq
N, M = list(map(int, input().split()))
edges = [set() for _ in range(N)]
for _ in range(M):
u, v = list(map(int, input().split()))
edges[u-1].add(v-1)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
step2 = [set() for _ in range(N)]
for u in range(N):
for v in edges[u]:
step2[u] |= edges[v]
cost = [-1 for _ in range(N)]
q = []
heapq.heappush(q, (0, S))
while len(q) != 0:
c, u = heapq.heappop(q)
if cost[u] != -1:
continue
cost[u] = c
for u2 in step2[u]:
rms = set()
for v in edges[u2]:
if cost[v] != -1:
rms.add(v)
else:
heapq.heappush(q, (c+1, v))
edges[u2] -= rms
print((cost[T]))
| import heapq
N, M = list(map(int, input().split()))
edges = [set() for _ in range(N)]
for _ in range(M):
u, v = list(map(int, input().split()))
edges[u-1].add(v-1)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
cost = [-1 for _ in range(N)]
q = []
heapq.heappush(q, (0, S))
step1memo = set()
step2memo = set()
step3memo = set()
while len(q) != 0:
c, u = heapq.heappop(q)
if cost[u] != -1:
continue
cost[u] = c
for u1 in edges[u]:
if u1 in step1memo:
continue
step1memo.add(u1)
for u2 in edges[u1]:
if u2 in step2memo:
continue
step2memo.add(u2)
for u3 in edges[u2]:
heapq.heappush(q, (c+1, u3))
print((cost[T]))
| p02991 |
N,M = list(map(int, input().split()))
UV = [list(map(int, input().split())) for _ in range(M)]
S,T = list(map(int, input().split()))
adjucent_dict={u:set() for u in range(1,N+1)}
for u,v in UV:
adjucent_dict.setdefault(u,set()).add(v)
#adjucent_dict.setdefault(v,set()).add(u)
two_adjucent_dict={u:set.union(*[adjucent_dict[v] for v in adjucent_dict[u]]) if adjucent_dict[u] else set() for u in range(1,N+1)}
three_adjucent_dict={u:set.union(*[adjucent_dict[v] for v in two_adjucent_dict[u]]) if two_adjucent_dict[u] else set() for u in range(1,N+1)}
visited=set([S])
just_visited=set([S])
n=1
while True:
three_step = set.union(*[three_adjucent_dict[u] for u in just_visited])
just_visited = three_step - visited
if T in just_visited:
print(n)
break
if len(just_visited)==0:
print((-1))
break
visited = visited & just_visited
n+=1 | N,M = list(map(int, input().split()))
UV = [list(map(int, input().split())) for _ in range(M)]
S,T = list(map(int, input().split()))
adjacent_dict={}
for u,v in UV:
adjacent_dict.setdefault((u,0),set()).add((v,1))
adjacent_dict.setdefault((u,1),set()).add((v,2))
adjacent_dict.setdefault((u,2),set()).add((v,0))
#BFS
to_visit = set([(S,0)])
visited = set()
n=1
while to_visit:
#print(to_visit, visited, n)
_next = set()
for v in to_visit:
if v in adjacent_dict:
_next = _next.union(adjacent_dict[v])
_next = _next - visited
if (T,0) in _next:
print((n//3))
break
to_visit = _next
visited = visited | _next
n += 1
#print(to_visit, visited, n)
else:
print((-1))
| p02991 |
from collections import defaultdict, deque
def kenkenpa(s, visited):
res = []
for v1 in e[s]:
if visited[v1][1]:
continue
visited[v1][1] = True
for v2 in e[v1]:
if visited[v2][2]:
continue
visited[v2][2] = True
for v3 in e[v2]:
if visited[v3][0]:
continue
visited[v3][0] = True
res.append(v3)
return res
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
S, T = list(map(int, input().split()))
q = deque([[S, 0]])
visited = [[False]*3 for _ in range(N+1)]
visited[S][0] = True
ans = -1
while q:
u, c = q.popleft()
if u == T:
ans = c
break
l = kenkenpa(u, visited)
for v in l:
q.append([v, c+1])
print(ans)
| from collections import defaultdict, deque
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
e[u].append(v)
'''
頂点を%3で考える(1つの頂点にを3つに分解する)
(u,0)->(v,1)
(v,1)->(u,2)
(u,2)->(v,0)
'''
S, T = list(map(int, input().split()))
q = deque([[S, 0]])
dist = [[-3]*3 for _ in range(N+1)]
dist[S][0] = 0
while q:
u, c = q.popleft()
for v in e[u]:
step = (c+1) % 3
if dist[v][step] < 0:
dist[v][step] = c+1
q.append([v, c+1])
print((dist[T][0]//3)) | p02991 |
def f(n, m):
to1 = {}
for _ in range(m):
u, v = list(map(int, input().split()))
to1.setdefault(u, [])
to1[u] += [v]
s, t = list(map(int, input().split()))
vst1 = set()
cnt = 0
to = {}
for i in range(1, n + 1):
ss = set([i])
for _ in range(3):
nss = []
for ii in ss:
if ii not in to1: continue
nss+=to1[ii]
ss = set(nss)
to[i] = list(ss)
# print(to)
ss = set([s])
while 1:
cnt += 1
# print(ss)
nss=set()
for i in ss:
if i not in to: continue
for j in to[i]:
nss.add(j)
ss = nss
# print(ss)
if t in ss:
print(cnt)
exit()
if ss <= vst1:
print((-1))
exit()
vst1 |= ss
n, m = list(map(int, input().split()))
f(n, m)
| def f(n, m):
to = {}
for _ in range(m):
u, v = list(map(int, input().split()))
to.setdefault(u, [])
to[u] += [v]
s, t = list(map(int, input().split()))
vst = [[False] * 3 for _ in range(n + 1)]
a = [s]
vst[s][0] = True
cnt = 0
while a:
b = []
cnt += 1
j = cnt % 3
for ak in a:
if ak not in to: continue
for i in to[ak]:
if vst[i][j]: continue
vst[i][j] = True
b.append(i)
if vst[t][0]:
print((cnt // 3))
exit()
a = b
print((-1))
n, m = list(map(int, input().split()))
f(n, m)
| p02991 |
import sys
input = sys.stdin.readline
from collections import deque
class Graph:
def __init__(self, n, directed=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.directed = directed
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.visited = [0]*self.n
self.info = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.directed == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bfs(self, start=1, goal=-1, time=0, save=False):
"""
:param start: スタート地点
:param goal: ゴール地点
:param save: True = 前回の探索結果を保持する
:return: （ループがあっても）最短距離。存在しなければ -1
"""
if self.decrement:
start -= 1
goal -= 1
if not save:
self.visited = [0] * self.n
p, t = start, time
self.visited[p] = 1
next_set = deque([(p, t)])
i = 0
while next_set:
p, t = next_set.popleft()
i += 1
if i > 10**6:
return -1
for q in self.edges[p]:
if (t+1)%3==0:
if self.visited[q] == 1:
continue
if q == goal:
return (t+1)//3
self.visited[q] = 1
next_set.append((q, t + 1))
return -1
##################################################################################################
N, M = list(map(int, input().split()))
graph = Graph(N, directed=True, decrement=True, destroy=False)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
S, T = list(map(int, input().split()))
print((graph.bfs(start=S, goal=T)))
| # https://atcoder.jp/contests/abc132/tasks/abc132_e
"""
タグ: bfs、拡張グラフ
"""
import sys
input = sys.stdin.readline
from collections import deque
class Graph:
def __init__(self, n, directed=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.directed = directed
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.visited = set()
self.info = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.directed == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bfs(self, start=1, goal=-1, time=0, save=False):
"""
:param start: スタート地点
:param goal: ゴール地点
:param save: True = 前回の探索結果を保持する
:return: （ループがあっても）最短距離。存在しなければ -1
"""
if self.decrement:
start -= 1
goal -= 1
p, t = start, time
self.visited.add((p,0))
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if (q, (t+1)%3) in self.visited:
continue
if q == goal and (t+1)%3==0:
return (t+1)//3
self.visited.add((q,(t+1)%3))
next_set.append((q, t + 1))
return -1
##################################################################################################
N, M = list(map(int, input().split()))
graph = Graph(N, directed=True, decrement=True, destroy=False)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
S, T = list(map(int, input().split()))
print((graph.bfs(start=S, goal=T)))
| p02991 |
#
import itertools
from collections import Counter
from collections import defaultdict
import bisect
from heapq import heappush, heappop
def next_kenp(node, edges):
nodes = set()
nodes2 = set()
for n1 in edges[node]:
for n2 in edges[n1]:
if n2 not in nodes2:
nodes2.add(n2)
for n2 in nodes2:
for n3 in edges[n2]:
nodes.add(n3)
return nodes
def main():
n, m = list(map(int, input().split()))
edges = defaultdict(list)
for _ in range(m):
u, v = list(map(int, input().split()))
edges[(u, 0)].append((v, 1))
edges[(u, 1)].append((v, 2))
edges[(u, 2)].append((v, 0))
s, t = list(map(int, input().split()))
# print(new_edges)
dones = set()
que = [((s, 0), 0)]
while que:
node, step = que.pop(0)
next_nodes = edges[node]
# print(next_nodes)
for n, l in next_nodes:
if n == t and l == 0:
print(((step + 1) // 3))
exit()
if (n, l) not in dones:
que.append(((n, l), step + 1))
dones.add((n, l))
print((-1))
if __name__ == '__main__':
main()
| #
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop
def main():
n, m = list(map(int, input().split()))
edges = defaultdict(list)
for _ in range(m):
u, v = list(map(int, input().split()))
edges[(u, 0)].append((v, 1))
edges[(u, 1)].append((v, 2))
edges[(u, 2)].append((v, 0))
s, t = list(map(int, input().split()))
# print(new_edges)
dones = set()
que = deque()
que.append(((s, 0), 0))
while que:
node, step = que.popleft()
next_nodes = edges[node]
# print(next_nodes)
for n, l in next_nodes:
if n == t and l == 0:
print(((step + 1) // 3))
exit()
if (n, l) not in dones:
que.append(((n, l), step + 1))
dones.add((n, l))
print((-1))
if __name__ == '__main__':
main()
| p02991 |
from collections import deque
import sys
input = sys.stdin.readline
def reachable_by_3steps_from(node, edges):
dist1 = edges[node]
reachable = []
for d1 in dist1:
dist2 = edges[d1]
for d2 in dist2:
reachable += edges[d2]
return reachable
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(m):
_from, to = list(map(int, input().split()))
edges[_from-1].append(to-1)
start, goal = list(map(int, input().split()))
skip_path = [[] for _ in range(n)]
for i in range(n):
skip_path[i] = reachable_by_3steps_from(i, edges)
todo = deque([])
seen = [False] * n
seen[start-1] = True
for to in skip_path[start-1]:
todo.append([to, 1])
if to == goal-1:
print((1))
exit()
while todo:
node, dist = todo.popleft()
if seen[node]:
continue
seen[node] = True
for to in skip_path[node]:
if seen[to]:
continue
todo.append([to, dist+1])
if to == goal-1:
print((dist+1))
exit()
print((-1)) | from collections import deque
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(m):
_from, to = list(map(int, input().split()))
edges[_from-1].append(to-1)
start, goal = list(map(int, input().split()))
todo = deque([])
seen = [[False] * n for i in range(3)]
seen[0][start-1] = True
for to in edges[start-1]:
dim = 1
dist = 1
todo.append([to, dim, dist])
while todo:
node, dim, dist = todo.popleft()
if seen[dim][node]:
continue
seen[dim][node] = True
dim += 1
if dim == 3:
dim = 0
for to in edges[node]:
if seen[dim][to]:
continue
todo.append([to, dim, dist+1])
if to == goal-1 and dim == 0:
print(((dist+1)//3))
exit()
print((-1)) | p02991 |
import os
import sys
from collections import defaultdict
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
N, M = list(map(int, sys.stdin.readline().split()))
UV = [list(map(int, sys.stdin.readline().split())) for _ in range(M)]
S, T = list(map(int, sys.stdin.readline().split()))
graph = defaultdict(set)
for u, v in UV:
graph[u].add(v)
memo = [[None] * (N+1) for _ in range(3)]
def dest(v, count):
if memo[count - 1][v] is not None:
return memo[count - 1][v]
if count <= 1:
memo[count - 1][v] = graph[v]
return graph[v]
ret = set()
for u in graph[v]:
ret |= dest(u, count - 1)
memo[count - 1][v] = ret
return ret
checked = set()
vs = {S}
i = 0
prev = 0
while True:
i += 1
s = set()
for v in vs:
s |= dest(v, 3)
checked |= vs
if T in s:
print(i)
break
if len(checked) == prev:
print((-1))
break
vs = s - checked
prev = len(checked)
| import os
import sys
from collections import defaultdict
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
N, M = list(map(int, sys.stdin.readline().split()))
UV = [list(map(int, sys.stdin.readline().split())) for _ in range(M)]
S, T = list(map(int, sys.stdin.readline().split()))
graph = defaultdict(set)
for u, v in UV:
graph[u].add(v)
vs = {S}
checked = set()
i = 0
prev = 0
while True:
i += 1
checked |= vs
for _ in range(3):
ss = set()
for v in vs:
ss |= graph[v]
vs = ss
if T in vs:
print(i)
break
if len(checked) == prev:
print((-1))
break
prev = len(checked)
| p02991 |
import heapq
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
N, M = list(map(int, sys.stdin.readline().split()))
UV = [list(map(int, sys.stdin.readline().split())) for _ in range(M)]
S, T = list(map(int, sys.stdin.readline().split()))
U = []
V = []
for u, v in UV:
U.extend([u, u + N, u + N * 2])
V.extend([v + N, v + N * 2, v])
# graph = csr_matrix(([1] * (M * 3), (U, V)), shape=(N * 3 + 1, N * 3 + 1))
# dist = dijkstra(graph, indices=S)[T]
# if dist < np.inf:
# print(int(dist // 3))
# else:
# print(-1)
#: :type: list of (list of int)
graph = [[] for _ in range(N * 3 + 1)]
for u, v in zip(U, V):
graph[u].append(v)
# S から T までの距離
heap = [(0, S)]
dist = [IINF] * (N * 3 + 1)
while heap:
d, v = heapq.heappop(heap)
if v == T:
print((int(d // 3)))
exit()
for u in graph[v]:
if d + 1 < dist[u]:
dist[u] = d + 1
heapq.heappush(heap, (d + 1, u))
print((-1))
| import heapq
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
N, M = list(map(int, sys.stdin.readline().split()))
VU = [list(map(int, sys.stdin.readline().split())) for _ in range(M)]
S, T = list(map(int, sys.stdin.readline().split()))
#: :type: list of (list of int)
graph = [[] for _ in range(N * 3 + 1)]
for v, u in VU:
graph[v].append(u + N)
graph[v + N].append(u + N * 2)
graph[v + N * 2].append(u)
heap = [(0, S)]
dist = [INF] * (N * 3 + 1)
ans = -1
while heap:
d, v = heapq.heappop(heap)
if v == T and d % 3 == 0:
ans = int(d // 3)
break
for u in graph[v]:
if d + 1 < dist[u]:
dist[u] = d + 1
heapq.heappush(heap, (d + 1, u))
print(ans)
| p02991 |
def dijkstra(edge,start,end) :
import heapq
minCosts = [float('inf') for _ in range(len(edge))]
nodeHeap = []
heapq.heappush(nodeHeap, (0, start)) # (cost, node)
while nodeHeap :
cost, node = heapq.heappop(nodeHeap)
if minCosts[node] <= cost :
continue
minCosts[node] = cost
for nextNode , weight in edge[node] :
newCost = cost + weight
heapq.heappush(nodeHeap, (newCost, nextNode))
dist = minCosts[endNode]
if dist == float('inf') :
return -1
return dist
N , M = list(map(int,input().split()))
# edges , costs
nodes = [[] for _ in range(3 * N)]
# 辺の入力
for _ in range(M) :
fromNode , toNode = list(map(int,input().split()))
fromNode -= 1
toNode -= 1
fromNode *= 3
toNode *= 3
nodes[fromNode].append((toNode + 1,1))
nodes[fromNode + 1].append((toNode + 2,1))
nodes[fromNode + 2].append((toNode,1))
# スタート ゴール
startNode , endNode = list(map(int,input().split()))
startNode -= 1
endNode -= 1
startNode *= 3
endNode *= 3
ans = dijkstra(nodes,startNode,endNode)
if ans == -1 :
print(ans)
else :
print((ans // 3)) | import heapq
N , M = list(map(int,input().split()))
# edges , costs
nodes = [[] for _ in range(3 * N)]
confilm = [False] * (3 * N) # 確定フラグ
costs = [-1] * (3 * N) # 最短経路
# 辺の入力
for _ in range(M) :
fromNode , toNode = list(map(int,input().split()))
fromNode -= 1
toNode -= 1
fromNode *= 3
toNode *= 3
nodes[fromNode].append((toNode + 1,1))
nodes[fromNode + 1].append((toNode + 2,1))
nodes[fromNode + 2].append((toNode,1))
# スタート ゴール
startNode , endNode = list(map(int,input().split()))
startNode -= 1
endNode -= 1
startNode *= 3
endNode *= 3
costs[startNode] = 0
q = [(0,startNode)]
# 探索
while q : # 空になるまで
nowCost , nowNode = heapq.heappop(q)
if confilm[nowNode] :
continue
confilm[nowNode] = True
# 長さを更新
for nextNode , cost in nodes[nowNode] :
# if not confilm[nextNode] : # 確定ノード以外
nextCost = nowCost + cost
if costs[nextNode] == -1 or nextCost < costs[nextNode] :
costs[nextNode] = nextCost # コストを更新
heapq.heappush(q,(nextCost,nextNode))
if costs[endNode] < 0 :
print((-1))
else :
print((costs[endNode] // 3)) | p02991 |
import sys,atexit
from io import BytesIO
inp = BytesIO(sys.stdin.buffer.read())
input = lambda:inp.readline().decode('ascii')
buf = BytesIO()
sys.stdout.write = lambda s: buf.write(s.encode('ascii'))
atexit.register(lambda:sys.__stdout__.buffer.write(buf.getvalue()))
n,m = list(map(int,input().split()))
C = [[] for _ in range(n)]
for _ in range(m):
a,b = [int(x)-1 for x in input().split()]
C[a].append(b)
start,end = [int(x)-1 for x in input().split()]
D = [(i,nei) for i in range(n) for nei in C[i]]
D = [(i,newnei) for i,nei in D for newnei in C[nei]]
D = [(i,newnei) for i,nei in D for newnei in C[nei]]
C = [set() for _ in range(n)]
for a,b in D:
C[a].add(b)
from collections import defaultdict as dd, deque
res = -1
Q = deque()
Q.append((start,0))
vis = [0]*n
while Q:
cur,dist = Q.popleft()
if cur == end:
res = dist
break
if vis[cur]: continue
vis[cur] = 1
for nei in C[cur]:
Q.append((nei,dist+1))
print(res)
| import sys,atexit
from io import BytesIO
inp = BytesIO(sys.stdin.buffer.read())
input = lambda:inp.readline().decode('ascii')
buf = BytesIO()
sys.stdout.write = lambda s: buf.write(s.encode('ascii'))
atexit.register(lambda:sys.__stdout__.buffer.write(buf.getvalue()))
n,m = list(map(int,input().split()))
C = [[] for _ in range(n)]
for _ in range(m):
a,b = [int(x)-1 for x in input().split()]
C[a].append(b)
start,end = [int(x)-1 for x in input().split()]
D = [(i,nei) for i in range(n) for nei in C[i]]
D = {(i,newnei) for i,nei in D for newnei in C[nei]}
D = {(i,newnei) for i,nei in D for newnei in C[nei]}
C = [[] for _ in range(n)]
for a,b in D:
C[a].append(b)
from collections import defaultdict as dd, deque
res = -1
Q = deque()
Q.append((start,0))
vis = [0]*n
while Q:
cur,dist = Q.popleft()
if cur == end:
res = dist
break
if vis[cur]: continue
vis[cur] = 1
for nei in C[cur]:
Q.append((nei,dist+1))
print(res)
| p02991 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
s = S()
b = list(set(s))
a = len(list(set(s)))
if a == 2 and s.count(b[0]) == s.count(b[1]) == 2:
print("Yes")
else:
print("No")
return
#B
def B():
n = II()
p = LI()
ans = 0
for i in range(1,n-1):
if (p[i - 1] < p[i] and p[i] < p[i + 1]) or (p[i + 1] < p[i] and p[i] < p[i - 1]):
ans += 1
print(ans)
return
#C
def C():
n = II()
d = LI()
d.sort()
ans = 0
for i in range(10**5+1):
if n // 2 == bisect_left(d, i):
ans += 1
print(ans)
return
def combination_mod(n, k, mod):
# power_funcを用いて(nCk) mod p を求める
# nCk = n!/((n-k)!k!)を使用
from math import factorial
if n < 0 or k < 0 or n < k: return 0
if n == 0 or k == 0: return 1
a = factorial(n) % mod
b = factorial(k) % mod
c = factorial(n - k) % mod
return (a * power_func(b, mod - 2, mod) * power_func(c, mod - 2, mod)) % mod
def power_func(a, b, mod):
# a^b mod p を求める
# bを2進数分解して高速累乗
if b == 0: return 1
if b % 2 == 0:
d = power_func(a, b // 2, mod)
return d * d % mod
if b % 2 == 1:
return (a * power_func(a, b - 1, mod)) % mod
#D
def D():
n, k = LI()
ans = 0
for i in range(1,k+1):
a = combination_mod(n - k + 1, i, mod)
b = combination_mod(k - 1, i - 1, mod)
print(((a*b)%mod))
return
def dijkstra(num, start, edge, g):
dist = [inf for i in range(num)]
dist[start] = 0
q = [(dist[start], start)]
while q:
du, u = heappop(q)
for j in edge[u]:
if dist[j] > du + 1:
dist[j] = du + 1
heappush(q, [dist[j], j])
if j == g:
return dist
return dist
#E
def E():
n, m = LI()
v = LIR_(m)
s, t = LI_()
edge = defaultdict(list)
for x,y in v:
edge[x].append(y)
newedge = defaultdict(list)
for key, i in list(edge.items()):
b = []
for j in i:
for k in edge[j]:
b.append(k)
if edge[j] == []:
a = edge.pop(j)
b = list(set(b))
newedge[key] = b
nnewedge = defaultdict(list)
for key, i in list(newedge.items()):
b = []
for j in i:
for k in edge[j]:
if key == k:
continue
b.append(k)
b = list(set(b))
nnewedge[key] = b
d = dijkstra(n, s, nnewedge, t)
if d[t] == inf:
print((-1))
else:
print((d[t]))
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == '__main__':
E()
| #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
s = S()
b = list(set(s))
a = len(list(set(s)))
if a == 2 and s.count(b[0]) == s.count(b[1]) == 2:
print("Yes")
else:
print("No")
return
#B
def B():
n = II()
p = LI()
ans = 0
for i in range(1,n-1):
if (p[i - 1] < p[i] and p[i] < p[i + 1]) or (p[i + 1] < p[i] and p[i] < p[i - 1]):
ans += 1
print(ans)
return
#C
def C():
n = II()
d = LI()
d.sort()
ans = 0
for i in range(10**5+1):
if n // 2 == bisect_left(d, i):
ans += 1
print(ans)
return
def combination_mod(n, k, mod):
# power_funcを用いて(nCk) mod p を求める
# nCk = n!/((n-k)!k!)を使用
from math import factorial
if n < 0 or k < 0 or n < k: return 0
if n == 0 or k == 0: return 1
a = factorial(n) % mod
b = factorial(k) % mod
c = factorial(n - k) % mod
return (a * power_func(b, mod - 2, mod) * power_func(c, mod - 2, mod)) % mod
def power_func(a, b, mod):
# a^b mod p を求める
# bを2進数分解して高速累乗
if b == 0: return 1
if b % 2 == 0:
d = power_func(a, b // 2, mod)
return d * d % mod
if b % 2 == 1:
return (a * power_func(a, b - 1, mod)) % mod
#D
def D():
n, k = LI()
ans = 0
for i in range(1,k+1):
a = combination_mod(n - k + 1, i, mod)
b = combination_mod(k - 1, i - 1, mod)
print(((a*b)%mod))
return
def dijkstra(num, start, edge, g):
dist = defaultdict(lambda: inf)
dist[(start,0)] = 0
q = [(dist[(start,0)], start, 0)]
while q:
du, u, t = heappop(q)
for j in edge[u]:
if t == 2:
t = -1
if dist[(j, t + 1)] > du + 1:
dist[(j, t + 1)] = du + 1
heappush(q, [dist[(j, t + 1)], j, t + 1])
return dist
#E
def E():
n, m = LI()
v = LIR_(m)
s, t = LI_()
edge = defaultdict(list)
for x,y in v:
edge[x].append(y)
d = dijkstra(n, s, edge, t)
if d[(t,0)] == inf:
print((-1))
else:
print((d[(t,0)]//3))
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == '__main__':
E()
| p02991 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#N = int(input())
N, M = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
edge = [[] for i in range(N)]
for i in range(M):#木の場合M=N-1
a,b = map(int,input().split())
edge[a-1].append(b-1)
S, T = map(int, input().split())
S-=1;T-=1
def dfs():
q=deque([(0,S)])
visited=[False]*N
while len(q):
d,e=q.popleft()#ここをpopleftにすると幅優先探索BFSになる
if d%3==0 and visited[e]:continue
elif d%3==0:
if e==T:
print(d//3)
return
visited[e]=True
for ne in edge[e]:
q.append((d+1,ne))
print(-1)
dfs()
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#N = int(input())
N, M = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
edge = [[] for i in range(N)]
for i in range(M):#木の場合M=N-1
a,b = map(int,input().split())
edge[a-1].append(b-1)
S, T = map(int, input().split())
S-=1;T-=1
def dfs():
q=deque([(0,S)])
visited=[[False]*N for _ in range(3)]
while len(q):
d,e=q.popleft()#ここをpopleftにすると幅優先探索BFSになる
if visited[d%3][e]:continue
elif d%3==0:
if e==T:
print(d//3)
return
visited[d%3][e]=True
for ne in edge[e]:
q.append((d+1,ne))
print(-1)
dfs()
if __name__ == "__main__":
main()
| p02991 |
import heapq
class Dijkstra:
def __init__(self, rote_map, start_point, goal_point=None):
self.rote_map = rote_map
self.start_point = start_point
self.goal_point = goal_point
def execute(self):
num_of_city = 3 * 10 ** 5 + 10
dist = [float("inf") for _ in range(num_of_city)]
prev = [float("inf") for _ in range(num_of_city)]
dist[self.start_point] = 0
heap_q = []
heapq.heappush(heap_q, (0, self.start_point))
route_count = [0 for _ in range(num_of_city)]
route_count[self.start_point] = 1
while len(heap_q) != 0:
prev_cost, src = heapq.heappop(heap_q)
if dist[src] < prev_cost:
continue
for dest, cost in list(self.rote_map[src].items()):
if cost != float("inf") and dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost
heapq.heappush(heap_q, (dist[dest], dest))
prev[dest] = src
if dist[dest] == dist[src] + cost:
route_count[dest] += route_count[src]
if self.goal_point is not None:
return self._get_path(self.goal_point, prev)
else:
return dist, route_count
def _get_path(self, goal, prev):
path = [goal]
dest = goal
while prev[dest] != float("inf"):
path.append(prev[dest])
dest = prev[dest]
return list(reversed(path))
N, M = list(map(int, input().split()))
from collections import defaultdict
graph = defaultdict(dict)
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph[u][v + N] = 1
graph[u + N][v + 2 * N] = 1
graph[u + 2 * N][v] = 1
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dj = Dijkstra(graph, S)
dist, _ = dj.execute()
if dist[T] % 3 == 0:
print((dist[T] // 3))
else:
print((-1))
| N, M = list(map(int, input().split()))
from collections import defaultdict, deque
graph = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph[u].append(v + N)
graph[u + N].append(v + 2 * N)
graph[u + 2 * N].append(v)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dist = [-1] * (3*N)
dist[S] = 0
q = deque([S])
while q:
v = q.popleft()
d = dist[v]
Vs = graph[v]
for u in Vs:
if dist[u] == -1:
q.append(u)
dist[u] = d + 1
if dist[T] != float("inf") and dist[T] % 3 == 0:
print((dist[T] // 3))
else:
print((-1))
| p02991 |
N, M = list(map(int, input().split()))
from collections import defaultdict, deque
graph = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph[u].append(v + N)
graph[u + N].append(v + 2 * N)
graph[u + 2 * N].append(v)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dist = [-1] * (3*N)
dist[S] = 0
q = deque([S])
while q:
v = q.popleft()
d = dist[v]
Vs = graph[v]
for u in Vs:
if dist[u] == -1:
q.append(u)
dist[u] = d + 1
if dist[T] != float("inf") and dist[T] % 3 == 0:
print((dist[T] // 3))
else:
print((-1))
| N, M = list(map(int, input().split()))
from collections import defaultdict, deque
graph = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph[u].append(v + N)
graph[u + N].append(v + 2 * N)
graph[u + 2 * N].append(v)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dist = [-1] * (3*N)
dist[S] = 0
que = deque([S])
while len(que) != 0:
q = que.popleft()
cost = dist[q]
for v in graph[q]:
if dist[v] == -1:
dist[v] = cost + 1
que.append(v)
if dist[T] % 3 == 0:
print((dist[T] // 3))
else:
print((-1))
| p02991 |
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(eval(input()))
s = lambda: eval(input())
N, M = nl()
from collections import defaultdict
edges = defaultdict(set)
for i in range(M):
u, v = nl()
edges[u].add(v+N)
edges[u+N].add(v+2*N)
edges[u+2*N].add(v)
S, T = nl()
import queue
q = queue.Queue()
q.put((S, 0))
done = defaultdict(bool)
done[S] = True
while not q.empty():
src, cost = q.get()
for dst in edges[src]:
if dst == T:
print(((cost+1) // 3))
import sys
sys.exit()
if not done[dst]:
done[dst] = True
q.put((dst, cost+1))
print((-1))
| nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(eval(input()))
s = lambda: eval(input())
N, M = nl()
from collections import defaultdict
edges = defaultdict(set)
for i in range(M):
u, v = nl()
edges[u].add(v+N)
edges[u+N].add(v+2*N)
edges[u+2*N].add(v)
S, T = nl()
import queue
q = queue.Queue()
q.put((S, 0))
done = [False] * (3*N+1)
done[S] = True
while not q.empty():
src, cost = q.get()
for dst in edges[src]:
if dst == T:
print(((cost+1) // 3))
import sys
sys.exit()
if not done[dst]:
done[dst] = True
q.put((dst, cost+1))
print((-1))
| p02991 |
n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
from collections import defaultdict, deque
g1 = defaultdict(set)
for u, v in uv:
g1[u-1].add(v-1)
s -= 1
t -= 1
f = False
visited = set([s])
q = deque([(s, 0)])
while q:
cur, d = q.popleft()
if cur == t:
f = True
break
for target1 in g1[cur]:
for target2 in g1[target1]:
for target3 in g1[target2]:
if target3 not in visited:
q.append((target3, d + 1))
if f:
print(d)
else:
print((-1))
| n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
import heapq
from collections import defaultdict
g1 = defaultdict(set)
for u, v in uv:
g1[u-1].add(v-1)
s -= 1
t -= 1
dist = [[float('inf')] * 3 for _ in range(n)]
dist[s][0] = 0
q = [(0, s, 0)] # (dist, pos, kenken)
heapq.heapify(q)
while q:
du, u, c = heapq.heappop(q)
if dist[u][c] < du:
continue
c2 = (c + 1) % 3
for v in g1[u]:
if du + 1 < dist[v][c2]:
dist[v][c2] = du + 1
heapq.heappush(q, (dist[v][c2], v, c2))
if dist[t][0] != float('inf'):
print((dist[t][0] // 3))
else:
print((-1))
| p02991 |
from collections import defaultdict
N, M = list(map(int, input().split()))
dic = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
dic[u-1] += [v-1]
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dist = [[float('inf')]*3 for i in range(N)]
ls = [float('inf')]*3
dist[S][0] = 0
q = [(S,0)]
flag = False
while q:
e, m = q.pop()
n = (m+1)%3
for p in dic[e]:
if p==T:
flag = True
if dist[p][n]>dist[e][m]+1:
dist[p][n] = dist[e][m]+1
q += [(p,n)]
if flag:
ans = dist[T][0] if dist[T][0]!=float('inf') else -1
print((ans//3))
else:
print((-1))
| from collections import defaultdict, deque
N, M = list(map(int, input().split()))
dic = defaultdict(list)
for i in range(M):
u, v = list(map(int, input().split()))
dic[u-1] += [v-1]
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dist = [[float('inf')]*3 for i in range(N)]
dist[S][0] = 0
q = deque([(S,0)])
flag = False
cnt = 0
while q:
cnt += 1
e, m = q.popleft()
n = (m+1)%3
for p in dic[e]:
if p==T:
flag = True
if dist[p][n]>dist[e][m]+1:
dist[p][n] = dist[e][m]+1
q += [(p,n)]
if flag:
ans = dist[T][0] if dist[T][0]!=float('inf') else -1
print((ans//3))
else:
print((-1)) | p02991 |
class Node:
def __init__(self, i):
self.num = i
self.ken = set()
self.kenken = set()
self.kenkenpa = set()
N, M = list(map(int, input().split()))
nodes = [Node(i) for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
nodes[v].ken.add(nodes[u])
s, t = list(map(int, input().split()))
s -= 1
t -= 1
for i in range(N):
for pre in nodes[i].ken:
nodes[i].kenken = nodes[i].kenken | pre.ken
for i in range(N):
for prepre in nodes[i].kenken:
nodes[i].kenkenpa = nodes[i].kenkenpa | prepre.ken
num = t
step = 0
check_list = [[num, step]]
check = [False] * N
ok = False
while len(check_list) > 0:
num, step = check_list.pop(0)
for pre in nodes[num].kenkenpa:
if pre.num == s:
print((step+1))
ok = True
break
if not check[pre.num]:
check[pre.num] = True
check_list.append([pre.num, step+1])
if ok:
break
if not ok:
print((-1))
| N, M = list(map(int, input().split()))
nodes = [[] for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
nodes[u].append(v)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
num = s
step = 0
q = [[num, step]]
check = [[False for i in range(N)] for j in range(3)]
ok = False
while len(q) > 0:
num, step = q.pop(0)
tmp = step % 3
if check[tmp][num]:
continue
if tmp == 0 and num == t:
print((step//3))
ok = True
break
for next in nodes[num]:
check[tmp][num] = True
q.append([next, step+1])
if not ok:
print((-1))
| p02991 |
#!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list([int(x)-1 for x in input().split()])
def li(): return list(eval(input()))
n, m = mi()
inv_adj = [set() for _ in range(n)]
inv_dist_2 = [set() for _ in range(n)]
inv_hopstepjump = [set() for _ in range(n)]
for _ in range(m):
u, v = mi_0()
inv_adj[v].add(u)
for i in range(n):
for s in inv_adj[i]:
inv_dist_2[i] |= inv_adj[s]
for i in range(n):
for s in inv_dist_2[i]:
inv_hopstepjump[i] |= inv_adj[s]
start, goal = mi_0()
appeared_vertice_set = set([goal])
q = deque([(goal, 0)])
while q:
# print(q)
u, turn = q.popleft()
if turn >= n:
break
if u == start:
print(turn)
exit()
for v in inv_hopstepjump[u]:
if v not in appeared_vertice_set:
appeared_vertice_set.add(v)
q.append((v, turn + 1))
print((-1))
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list([int(x)-1 for x in input().split()])
def li(): return list(eval(input()))
# n, m = mi()
# inv_adj = [set() for _ in range(n)]
# inv_dist_2 = [set() for _ in range(n)]
# inv_hopstepjump = [set() for _ in range(n)]
# for _ in range(m):
# u, v = mi_0()
# inv_adj[v].add(u)
# for i in range(n):
# for s in inv_adj[i]:
# inv_dist_2[i] |= inv_adj[s]
# for i in range(n):
# for s in inv_dist_2[i]:
# inv_hopstepjump[i] |= inv_adj[s]
# start, goal = mi_0()
# appeared_vertice_set = set([goal])
# q = deque([(goal, 0)])
# while q:
# # print(q)
# u, turn = q.popleft()
# if turn >= n:
# break
# if u == start:
# print(turn)
# exit()
# for v in inv_hopstepjump[u]:
# if v not in appeared_vertice_set:
# appeared_vertice_set.add(v)
# q.append((v, turn + 1))
# print(-1)
"""
set を作るところで最悪 O(n^2) より 2 つくらい TLE
経路長 3 の倍数というところで start からの経由数の剰余 (mod 3) を管理する、という方針は思いついたが... それをノードを増やすことで管理するという発想に至らず。
"""
n, m = mi()
adj = [[] for _ in range(n * 3)]
for _ in range(m):
a, b = mi_0()
adj[a * 3].append(b * 3 + 1)
adj[a * 3 + 1].append(b * 3 + 2)
adj[a * 3 + 2].append(b * 3)
start, goal = mi_0()
start *= 3
goal *= 3
q = deque([(start, 0)])
visited = [False] * (n * 3)
while q:
u, dist = q.popleft()
if dist > 3 * n:
break
if u == goal:
assert (dist % 3 == 0)
print((dist // 3))
return
if not visited[u]:
for v in adj[u]:
if not visited[v]:
q.append((v, dist + 1))
print((-1))
if __name__ == "__main__":
main()
| p02991 |
import heapq as h
import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
hen=[[] for i in range(0,N)]
for i in range(0,M):
u,v=list(map(int,input().split()))
hen[u-1].append(v-1)
S,T=list(map(int,input().split()))
triplehen=[[] for i in range(0,N)]
for i in range(0,N):
q=[i]
h.heapify(q)
sub=[]
h.heapify(sub)
count=0
while 3>count:
while q!=[]:
x=h.heappop(q)
for p in hen[x]:
h.heappush(sub,p)
if q==[]:
count+=1
if count==3:
for j in sub:
triplehen[i].append(j)
else:
if sub==[]:
count=3
q=sub
sub=[]
h.heapify(sub)
break
triplehen=[list(set(triplehen[i])) for i in range(0,N)]
ans=[-1 for i in range(0,N)]
ans[S-1]=0
q=[]
q.append(S-1)
h.heapify(q)
sub=[]
h.heapify(sub)
count=0
while q!=[]:
while q!=[]:
x=h.heappop(q)
for p in triplehen[x]:
if ans[p]==-1:
h.heappush(sub,p)
if q==[]:
count+=1
for j in sub:
ans[j]=count
q=sub
sub=[]
h.heapify(sub)
break
print((ans[T-1]))
| import heapq as h
N,M=list(map(int,input().split()))
hen={(i,j):[] for i in range(0,N) for j in range(0,3)}
for i in range(0,M):
u,v=list(map(int,input().split()))
hen[(u-1,0)].append((v-1,1))
hen[(u-1,1)].append((v-1,2))
hen[(u-1,2)].append((v-1,0))
S,T=list(map(int,input().split()))
start=(S-1,0)
goal=(T-1,0)
distance={(i,j):-1 for i in range(0,N) for j in range(0,3)}
q=[]
q.append(start)
distance[start]=0
h.heapify(q)
sub=[]
h.heapify(sub)
while q!=[]:
while q!=[]:
x=h.heappop(q)
for p in hen[x]:
if distance[p]==-1:
h.heappush(sub,p)
distance[p]=distance[x]+1
#何らかの操作
#ここでsubキューに次に使うものを格納
if q==[]:
q=sub
sub=[]
h.heapify(sub)
break
if distance[goal]==-1:
print((-1))
else:
print((distance[goal]//3)) | p02991 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N,M = IL()
graph = [[] for i in range(N)]
for _ in range(M):
a,b = IL()
graph[a-1].append(b-1)
S,T = IL()
S,T = S-1,T-1
graph2 = [set() for i in range(N)]
for x in range(N):
for y in graph[x]:
for z in graph[y]:
graph2[x].add(z)
graph3 = [set() for i in range(N)]
for x in range(N):
for y in graph2[x]:
for z in graph[y]:
graph3[x].add(z)
def bfs(graph, start):
N = len(graph)
d = [INF] * N
d[start] = 0
q = deque([start])
while q:
u = q.popleft()
for v in graph[u]:
if d[v] != INF: continue
d[v] = d[u] + 1
q.append(v)
return d
d = bfs(graph3,S)
if d[T] == INF:
print((-1))
else:
print((d[T])) | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N,M = IL()
graph = [[] for i in range(N*3)]
for _ in range(M):
a,b = IL()
a,b = a-1,b-1
graph[a*3].append(b*3+1)
graph[a*3+1].append(b*3+2)
graph[a*3+2].append(b*3)
S,T = IL()
S,T = S-1,T-1
def bfs(graph, start):
N = len(graph)
d = [INF] * N
d[start] = 0
q = deque([start])
while q:
u = q.popleft()
for v in graph[u]:
if d[v] != INF: continue
d[v] = d[u] + 1
q.append(v)
return d
d = bfs(graph,S*3)
if d[T*3] == INF:
print((-1))
else:
print((d[T*3]//3)) | p02991 |
from collections import deque
def bfs(start, goal, g, visited):
q = deque([start])
visited[start] = 0
while q:
curr_node = q.popleft()
if curr_node == goal:
return
for next1_node in g[curr_node]:
for next2_node in g[next1_node]:
for next3_node in g[next2_node]:
if visited[next3_node] >= 0: continue
visited[next3_node] = visited[curr_node] + 1
q.append(next3_node)
def main():
n,m = list(map(int, input().split()))
g = [ [] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, input().split()))
g[u].append(v)
s,t = list(map(int, input().split()))
visited = [-1]*(n+1)
visited[0] = 0
bfs(s, t, g, visited)
print((visited[t]))
if __name__ == "__main__":
main() | from collections import deque
def bfs(start, goal, g, n, visited):
visited1 = [False]*(n+1)
visited2 = [False]*(n+1)
q = deque([start])
visited[start] = 0
while q:
curr_node = q.popleft()
if curr_node == goal:
return
for next1_node in g[curr_node]:
if visited1[next1_node]: continue
visited1[next1_node] = True
for next2_node in g[next1_node]:
if visited2[next2_node]: continue
visited2[next2_node] = True
for next3_node in g[next2_node]:
if visited[next3_node] >= 0: continue
visited[next3_node] = visited[curr_node] + 1
q.append(next3_node)
def main():
n,m = list(map(int, input().split()))
g = [ [] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, input().split()))
g[u].append(v)
s,t = list(map(int, input().split()))
visited = [-1]*(n+1)
visited[0] = 0
bfs(s, t, g, n, visited)
print((visited[t]))
if __name__ == "__main__":
main() | p02991 |
from heapq import *
import sys
input=sys.stdin.readline
def main():
N,M=list(map(int,input().split()))
G=[set() for i in range(N)]
for i in range(M):
u,v=list(map(int,input().split()))
u,v=u-1,v-1
G[u].add(v)
S,T=list(map(int,input().split()))
A=[set() for i in range(N)]
for i in range(N):
for v in G[i]:
A[i]=A[i].union(G[v])
B=[set() for i in range(N)]
for i in range(N):
for v in G[i]:
B[i]=B[i].union(A[v])
INF=10**9+7
def dijkstra(G,s):
d=[INF]*N
d[s]=0
visited={s}
que=[(0,s)]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node in G[v]:
cost=1
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,(d[node],node))
return d
d=dijkstra(B,S-1)
if d[T-1]==INF:
print((-1))
else:
print((d[T-1]))
if __name__=='__main__':#おまじない
main()
| from heapq import *
import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
G=[[] for i in range(3*N)]
for i in range(M):
u,v=list(map(int,input().split()))
u,v=u-1,v-1
G[3*u+0].append([3*v+1,0])
G[3*u+1].append([3*v+2,0])
G[3*u+2].append([3*v+0,1])
S,T=list(map(int,input().split()))
INF=10**9+7
def dijkstra(G,s):
d=[INF]*(3*N)
d[s]=0
visited={s}
que=[(0,s)]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,(d[node],node))
return d
d=dijkstra(G,(S-1)*3)
if d[(T-1)*3]==INF:
print((-1))
else:
print((d[(T-1)*3]))
| p02991 |
import sys
input = sys.stdin.readline
N,M=list(map(int,input().split()))
adj=[[] for _ in range(N)]
adj_2=[[] for _ in range(N)]
adj_3=[[] for _ in range(N)]
for i in range(M):
u,v=list(map(int,input().split()))
adj[u-1].append(v-1)
S,T=list(map(int,input().split()))
for i in range(N):
for j in range(len(adj[i])):
a=adj[i][j]
for k in range(len(adj[a])):
adj_2[i].append(adj[a][k])
adj_2[i]=list(set(adj_2[i]))#重複データを外す
for i in range(N):
for j in range(len(adj_2[i])):
a=adj_2[i][j]
for k in range(len(adj[a])):
adj_3[i].append(adj[a][k])
adj_3[i]=list(set(adj_3[i]))#重複データを外す
##########################################
inf=10**9
import heapq
class Dijkstra():
"""
・有向 / 無向は問わない(無向の場合は，逆向きの辺もたす)
・負のコストがない場合のみ
・計算量はO(E log|V|)
・heapを使うことで頂点を走査する必要がなくなる（代わりに，距離更新したものは確定でなくともqueに入れておく）
"""
#最短のpathをたす
class Edge():
#重み付き有向辺
def __init__(self, _to, _cost):
self.to =_to
self.cost = _cost
def __init__(self, V):
#引数Vは頂点数
self.G = [[] for _ in range(V)] #隣接リストG[u][i]が頂点uのi番目の辺
self. _E = 0 #辺の数
self._V = V #頂点数
#proparty - 辺の数
def E(self):
return self._E
#proparty - 頂点数
def V(self):
return self._V
def add(self, _from, _to, _cost):
#2頂点と辺のコストを追加
self.G[_from].append(self.Edge(_to,_cost))
self._E +=1
def add2(self, _from, _to, _cost):
#2頂点と辺のコスト（無向）を追加
self.G[_from].append(self.Edge(_to, _cost))
self.G[_to].append(self.Edge(_from, _cost))
self._E +=1
def shortest_path(self,s):
#始点sから頂点iまでの最短経路長のリストを返す
que = [] #priority queue
d = [inf] * self.V()
prev = [None]*self.V() #prev[j]は，sからjへ最短経路で行くときのjの一つ前の場所
d[s] = 0
heapq.heappush(que,(0,s)) #始点の距離と頂点番号をヒープに追加
while len(que)!=0:
#キューに格納されてある中で一番コストが小さい頂点を取り出す
cost,v = heapq.heappop(que)
#キューに格納された最短経路長候補がdの距離よりも大きい場合に処理をスキップ
if d[v] < cost:
continue
#頂点vに隣接する各頂点iに対して，vを経由した場合の距離を計算して，これがd[i]よりも小さい場合に更新
for i in range(len(self.G[v])):
e = self.G[v][i] #vのi個目の隣接辺
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost #更新
prev[e.to] = v
heapq.heappush(que,(d[e.to],e.to)) #queに新たな最短経路長候補を追加
return d
########################
djk = Dijkstra(N)
for i in range(N):
for j in range(len(adj_3[i])):
djk.add(i,adj_3[i][j],1)
d = djk.shortest_path(S-1)
ans=d[T-1]
if ans==inf:
ans=-1
print(ans) | ##########################################
inf=10**9
import heapq
class Dijkstra():
"""
・有向 / 無向は問わない(無向の場合は，逆向きの辺もたす)
・負のコストがない場合のみ
・計算量はO(E log|V|)
・heapを使うことで頂点を走査する必要がなくなる（代わりに，距離更新したものは確定でなくともqueに入れておく）
"""
class Edge():
#重み付き有向辺
def __init__(self, _to, _cost):
self.to =_to
self.cost = _cost
def __init__(self, V):
#引数Vは頂点数
self.G = [[] for _ in range(V)] #隣接リストG[u][i]が頂点uのi番目の辺
self. _E = 0 #辺の数
self._V = V #頂点数
#proparty - 辺の数
def E(self):
return self._E
#proparty - 頂点数
def V(self):
return self._V
def add(self, _from, _to, _cost):
#2頂点と辺のコストを追加
self.G[_from].append(self.Edge(_to,_cost))
self._E +=1
def add2(self, _from, _to, _cost):
#2頂点と辺のコスト（無向）を追加
self.G[_from].append(self.Edge(_to, _cost))
self.G[_to].append(self.Edge(_from, _cost))
self._E +=1
def shortest_path(self,s):
#始点sから頂点iまでの最短経路長のリストを返す
que = [] #priority queue
d = [inf] * self.V()
prev = [None]*self.V() #prev[j]は，sからjへ最短経路で行くときのjの一つ前の場所
d[s] = 0
heapq.heappush(que,(0,s)) #始点の距離と頂点番号をヒープに追加
while len(que)!=0:
#キューに格納されてある中で一番コストが小さい頂点を取り出す
cost,v = heapq.heappop(que)
#キューに格納された最短経路長候補がdの距離よりも大きい場合に処理をスキップ
if d[v] < cost:
continue
#頂点vに隣接する各頂点iに対して，vを経由した場合の距離を計算して，これがd[i]よりも小さい場合に更新
for i in range(len(self.G[v])):
e = self.G[v][i] #vのi個目の隣接辺
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost #更新
prev[e.to] = v
heapq.heappush(que,(d[e.to],e.to)) #queに新たな最短経路長候補を追加
return d
########################
#グラフの頂点を3倍化
import sys
input = sys.stdin.readline
N,M=list(map(int,input().split()))
djk = Dijkstra(N*3)
for i in range(M):
u,v=list(map(int,input().split()))
u-=1
v-=1
djk.add(u,N+v,1)
djk.add(N+u,2*N+v,1)
djk.add(2*N+u,v,1)
S,T=list(map(int,input().split()))
d = djk.shortest_path(S-1)
ans=d[T-1]//3
if ans==inf//3:
ans=-1
print(ans) | p02991 |
##########################################
inf=10**9
import heapq
class Dijkstra():
"""
・有向 / 無向は問わない(無向の場合は，逆向きの辺もたす)
・負のコストがない場合のみ
・計算量はO(E log|V|)
・heapを使うことで頂点を走査する必要がなくなる（代わりに，距離更新したものは確定でなくともqueに入れておく）
"""
class Edge():
#重み付き有向辺
def __init__(self, _to, _cost):
self.to =_to
self.cost = _cost
def __init__(self, V):
#引数Vは頂点数
self.G = [[] for _ in range(V)] #隣接リストG[u][i]が頂点uのi番目の辺
self. _E = 0 #辺の数
self._V = V #頂点数
#proparty - 辺の数
def E(self):
return self._E
#proparty - 頂点数
def V(self):
return self._V
def add(self, _from, _to, _cost):
#2頂点と辺のコストを追加
self.G[_from].append(self.Edge(_to,_cost))
self._E +=1
def add2(self, _from, _to, _cost):
#2頂点と辺のコスト（無向）を追加
self.G[_from].append(self.Edge(_to, _cost))
self.G[_to].append(self.Edge(_from, _cost))
self._E +=1
def shortest_path(self,s):
#始点sから頂点iまでの最短経路長のリストを返す
que = [] #priority queue
d = [inf] * self.V()
prev = [None]*self.V() #prev[j]は，sからjへ最短経路で行くときのjの一つ前の場所
d[s] = 0
heapq.heappush(que,(0,s)) #始点の距離と頂点番号をヒープに追加
while len(que)!=0:
#キューに格納されてある中で一番コストが小さい頂点を取り出す
cost,v = heapq.heappop(que)
#キューに格納された最短経路長候補がdの距離よりも大きい場合に処理をスキップ
if d[v] < cost:
continue
#頂点vに隣接する各頂点iに対して，vを経由した場合の距離を計算して，これがd[i]よりも小さい場合に更新
for i in range(len(self.G[v])):
e = self.G[v][i] #vのi個目の隣接辺
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost #更新
prev[e.to] = v
heapq.heappush(que,(d[e.to],e.to)) #queに新たな最短経路長候補を追加
return d
########################
#グラフの頂点を3倍化
import sys
input = sys.stdin.readline
N,M=list(map(int,input().split()))
djk = Dijkstra(N*3)
for i in range(M):
u,v=list(map(int,input().split()))
u-=1
v-=1
djk.add(u,N+v,1)
djk.add(N+u,2*N+v,1)
djk.add(2*N+u,v,1)
S,T=list(map(int,input().split()))
d = djk.shortest_path(S-1)
ans=d[T-1]//3
if ans==inf//3:
ans=-1
print(ans) | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
##########################################
import heapq
class Dijkstra():
"""
・有向 / 無向は問わない(無向の場合は，逆向きの辺もたす)
・負のコストがない場合のみ
・計算量はO(E log|V|)
・heapを使うことで頂点を走査する必要がなくなる（代わりに，距離更新したものは確定でなくともqueに入れておく）
・復元なし
"""
#最短のpathをたす
class Edge():
#重み付き有向辺
def __init__(self, _to, _cost):
self.to =_to
self.cost = _cost
def __init__(self, V):
#引数Vは頂点数
self.inf=10**20
self.G = [[] for _ in range(V)] #隣接リストG[u][i]が頂点uのi番目の辺
self. _E = 0 #辺の数
self._V = V #頂点数
#proparty - 辺の数
def E(self):
return self._E
#proparty - 頂点数
def V(self):
return self._V
def add(self, _from, _to, _cost):
#2頂点と辺のコストを追加
self.G[_from].append(self.Edge(_to,_cost))
self._E +=1
def add2(self, _from, _to, _cost):
#2頂点と辺のコスト（無向）を追加
self.G[_from].append(self.Edge(_to, _cost))
self.G[_to].append(self.Edge(_from, _cost))
self._E +=2
def shortest_path(self,s):#,g):
#始点sから頂点iまでの最短経路長のリストを返す
que = [] #priority queue
d = [self.inf] * self.V()
#prev = [None]*self.V() #prev[j]は，sからjへ最短経路で行くときのjの一つ前の場所
#復元で使う
d[s] = 0
heapq.heappush(que,(0,s)) #始点の距離と頂点番号をヒープに追加
while len(que)!=0:
#キューに格納されてある中で一番コストが小さい頂点を取り出す
cost,v = heapq.heappop(que)
#キューに格納された最短経路長候補がdの距離よりも大きい場合に処理をスキップ
if d[v] < cost:
continue
#頂点vに隣接する各頂点iに対して，vを経由した場合の距離を計算して，これがd[i]よりも小さい場合に更新
for i in range(len(self.G[v])):
e = self.G[v][i] #vのi個目の隣接辺
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost #更新
#prev[e.to] = v
#復元で使う
heapq.heappush(que,(d[e.to],e.to)) #queに新たな最短経路長候補を追加
"""#sからgまでの最短経路
path = []
pos = g #今いる場所，ゴールで初期化
for _ in range(self.V()+1):
path.append(pos)
if pos == s:
break
#print("pos:",format(pos))
pos = prev[pos]
path.reverse()
#print(path)"""
return d#,path
########################
mod=10**9+7
N,M=MI()
djk=Dijkstra(3*N)
for _ in range(M):
u,v=MI()
u-=1
v-=1
djk.add(u,v+N,1)
djk.add(u+N,v+2*N,1)
djk.add(u+2*N,v,1)
S,T=MI()
S-=1
T-=1
D=djk.shortest_path(S)
ans=D[T] //3
if ans>10**7:
ans=-1
print(ans)
main()
| p02991 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
graph = [[] for _ in range(n)]
for u, v in LIR(m):
graph[u - 1] += [v - 1]
s, t = LI()
dist = [[INF for _ in range(3)] for _ in range(n)]
dist[s - 1][0] = 0
que = deque([(s - 1, 0)])
while que:
cur, cost = que.pop()
for nxt in graph[cur]:
if cost + 1 < dist[nxt][(cost + 1) % 3]:
dist[nxt][(cost + 1) % 3] = cost + 1
que += [(nxt, cost + 1)]
if dist[t - 1][0] == INF:
print((-1))
else:
print((dist[t - 1][0] // 3)) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
graph = [[] for _ in range(n)]
for u, v in LIR(m):
graph[u - 1] += [v - 1]
s, t = LI()
dist = [[INF for _ in range(3)] for _ in range(n)]
dist[s - 1][0] = 0
que = deque([(s - 1, 0)])
while que:
cur, cost = que.popleft()
for nxt in graph[cur]:
if cost + 1 < dist[nxt][(cost + 1) % 3]:
dist[nxt][(cost + 1) % 3] = cost + 1
que += [(nxt, cost + 1)]
if dist[t - 1][0] == INF:
print((-1))
else:
print((dist[t - 1][0] // 3)) | p02991 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
graph = [[] for _ in range(n)]
for u, v in LIR(m):
graph[u - 1] += [v - 1]
s, t = LI()
dist = [[INF for _ in range(3)] for _ in range(n)]
dist[s - 1][0] = 0
que = deque([(s - 1, 0)])
while que:
cur, cost = que.popleft()
for nxt in graph[cur]:
if cost + 1 < dist[nxt][(cost + 1) % 3]:
dist[nxt][(cost + 1) % 3] = cost + 1
que += [(nxt, cost + 1)]
if dist[t - 1][0] == INF:
print((-1))
else:
print((dist[t - 1][0] // 3)) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [[] for _ in range(n)]
for _ in range(m):
x, y = LI()
G[x - 1] += [y - 1]
dist = [[INF] * n for _ in range(3)]
s, t = LI()
dist[0][s - 1] = 0
dq = deque([(0, s - 1)])
while dq:
cost, u = dq.popleft()
for v in G[u]:
if cost + 1 < dist[(cost + 1) % 3][v]:
dist[(cost + 1) % 3][v] = cost + 1
dq += [(cost + 1, v)]
ans = dist[0][t - 1]
if ans == INF:
print((-1))
else:
print((ans // 3))
| p02991 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [[] for _ in range(n)]
for _ in range(m):
x, y = LI()
G[x - 1] += [y - 1]
dist = [[INF] * n for _ in range(3)]
s, t = LI()
dist[0][s - 1] = 0
dq = deque([(0, s - 1)])
while dq:
cost, u = dq.popleft()
for v in G[u]:
if cost + 1 < dist[(cost + 1) % 3][v]:
dist[(cost + 1) % 3][v] = cost + 1
dq += [(cost + 1, v)]
ans = dist[0][t - 1]
if ans == INF:
print((-1))
else:
print((ans // 3))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [[] for _ in range(n)]
for x, y in LIR(m):
G[x - 1] += [y - 1]
dist = [[INF] * n for _ in range(3)]
s, t = LI()
dist[0][s - 1] = 0
dq = deque([(0, s - 1)])
while dq:
cost, u = dq.popleft()
for v in G[u]:
if cost + 1 < dist[(cost + 1) % 3][v]:
dist[(cost + 1) % 3][v] = cost + 1
dq += [(cost + 1, v)]
ans = dist[0][t - 1]
if ans == INF:
print((-1))
else:
print((ans // 3))
| p02991 |
n,m=list(map(int,input().split()))
u,v=[],[]
path=[[] for i in range(n)]
for i in range(m):
ui,vi=[int(x)-1 for x in input().split()]
path[ui].append(vi)
# path[vi].append(ui)
s,t=[int(x)-1 for x in input().split()]
from collections import deque
q=deque()
q.append((s,0))
# print(path)
check=[False]*n
while q:
# print(q)
p,num=q.popleft()
if num%3!=0:
for i in path[p]:
q.append((i,num+1))
continue
elif p==t:
print((num//3))
import sys
sys.exit()
elif check[p]==True:
continue
else:
for i in path[p]:
q.append((i,num+1))
check[p]=True
print((-1)) | n,m=list(map(int,input().split()))
u,v=[],[]
path=[[] for i in range(n)]
for i in range(m):
ui,vi=[int(x)-1 for x in input().split()]
path[ui].append(vi)
# path[vi].append(ui)
s,t=[int(x)-1 for x in input().split()]
from collections import deque
q=deque()
q.append((s,0))
# print(path)
check=[[False]*n for x in [0,1,2]]
while q:
# print(q)
p,num=q.popleft()
if check[num%3][p]==True:
continue
if num%3!=0:
for i in path[p]:
q.append((i,num+1))
check[num%3][p]=True
continue
elif p==t:
print((num//3))
import sys
sys.exit()
else:
for i in path[p]:
q.append((i,num+1))
check[0][p]=True
print((-1)) | p02991 |
#逆探索
N, M = list(map(int, input().split()))
E = []
for i in range(M):
e = list(map(int, input().split()))
e.reverse()
E.append(e)
S, T = list(map(int, input().split()))
keiro = []
for i in range(N):
keiro.append(set())
for e in E:
keiro[e[0]-1].add(e[1])
rireki = [{T}]
before = set()
after = {T}
flag = 0
while flag == 0:
for i in range(3):
before = after
after = set()
for b in before:
after = after | keiro[b-1]
after = after | rireki[-1]
for r in rireki:
if r == after:
flag = 1
if {S} & after == {S}:
flag = 2
rireki.append(after | rireki[-1])
after = after - rireki[-2]
if flag == 1:
print((-1))
if flag == 2:
print((len(rireki)-1))
| #順探索
N, M = list(map(int, input().split()))
E = []
for i in range(M):
e = list(map(int, input().split()))
E.append(e)
S, T = list(map(int, input().split()))
keiro = [set()]
for i in range(N):
keiro.append(set())
for e in E:
keiro[e[0]].add(e[1])
reached = {S}
before = set()
after = reached
flag = 0 #flag = 0: 探索中 flag = 1: 解無し flag = 2:解発見
counter = 0
while flag == 0:
for i in range(3):
before = after
after = set()
for b in before:
after = after | keiro[b]
counter = counter + 1
if after - reached == set():
flag = 1
if {T} & after == {T}:
flag = 2
after = after - reached
reached = reached | after
if flag == 1:
print((-1))
if flag == 2:
print(counter)
| p02991 |
from collections import deque
N, M = list(map(int, input().split()))
vec = [[] for _ in range(N)]
for _ in range(M) :
u, v = list(map(int, input().split()))
vec[u-1].append(v-1)
S, T = list(map(int, input().split()))
S, T = S - 1, T - 1
visited = [False] * N
visited[S] = True
queue1 = deque([(0, S)])
while queue1 :
cost, i = queue1.popleft()
queue2 = deque([(0, i)])
while queue2 :
step, q = queue2.popleft()
if step == 2 :
for j in vec[q] :
if j == T :
print((cost + 1))
exit()
if not visited[j] :
visited[j] = True
queue1.append((cost + 1, j))
else :
for j in vec[q] :
queue2.append((step + 1, j))
print((-1))
| from collections import deque
N, M = list(map(int, input().split()))
vec = [[] for _ in range(N)]
for _ in range(M) :
u, v = list(map(int, input().split()))
vec[u-1].append(v-1)
S, T = list(map(int, input().split()))
S, T = S - 1, T - 1
visited = [[False] * N for _ in range(3)]
visited[0][S] = True
queue = deque([(S, 0)])
while queue :
q, cost = queue.popleft()
p = (cost + 1) % 3
for i in vec[q] :
if p == 0 and i == T :
print(((cost + 1) // 3))
exit()
if not visited[p][i] :
visited[p][i] = True
queue.append((i, cost + 1))
print((-1))
| p02991 |
from collections import deque
N,M = list(map(int,input().split()))
data = [[] for _ in range(3*N)]
for i in range(M):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
data[3*u].append(3*v+1)
data[3*u+1].append(3*v+2)
data[3*u+2].append(3*v)
S,T = list(map(int,input().split()))
S -= 1
T -= 1
inf = 10**6
stack = deque([[3*S,0]])
time = [inf] * (3*N)
while stack:
x = stack.pop()
for y in data[x[0]]:
if time[y] > x[1] + 1:
time[y] = x[1] + 1
stack.append([y,x[1] + 1])
if time[3*T] == inf:
print((-1))
else:
print((time[3*T]//3)) | from collections import deque
N,M = list(map(int,input().split()))
data = [[] for _ in range(3*N)]
for i in range(M):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
data[3*u].append(3*v+1)
data[3*u+1].append(3*v+2)
data[3*u+2].append(3*v)
S,T = list(map(int,input().split()))
S -= 1
T -= 1
inf = 10**6
stack = deque([[3*S,0]])
time = [inf] * (3*N)
while stack:
x = stack.popleft()
for y in data[x[0]]:
if time[y] > x[1] + 1:
time[y] = x[1] + 1
stack.append([y,x[1] + 1])
if time[3*T] == inf:
print((-1))
else:
print((time[3*T]//3)) | p02991 |
from collections import defaultdict, deque
import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
e = defaultdict(list)
for i in range(M):
a, b = list(map(int, input().split()))
e[(a, 0)].append((b, 1))
e[(a, 1)].append((b, 2))
e[(a, 2)].append((b, 0))
S, T = list(map(int, input().split()))
d = deque()
d.appendleft((S, 0))
inf = float('inf')
dist = defaultdict(lambda: inf)
dist[(S, 0)] = 0
def BFS(now):
for v in e[now]:
if(dist[v] > dist[now] + 1):
dist[v] = dist[now] + 1
if(v == (T, 0)):
return
BFS(v)
return
BFS((S, 0))
ans = dist[(T, 0)]
if(ans == inf):
print((-1))
else:
print((ans//3))
| from collections import deque, defaultdict
N, M = list(map(int, input().split()))
edge = defaultdict(list)
for i in range(M):
a, b = list(map(int, input().split()))
edge[(a, 0)].append((b, 1))
edge[(a, 1)].append((b, 2))
edge[(a, 2)].append((b, 0))
S, T = list(map(int, input().split()))
inf = float('inf')
dist = {}
for i in range(1, N+1):
dist[(i, 0)] = inf
dist[(i, 1)] = inf
dist[(i, 2)] = inf
dist[(S, 0)] = 0
dq = deque()
dq.append((S, 0))
while dq:
v = dq.popleft()
if v == (T, 0):
break
for u in edge[v]:
if dist[u] < inf: continue
dq.append(u)
dist[u] = dist[v] + 1
if(dist[(T, 0)] == inf):
print((-1))
else:
print((dist[(T, 0)]//3))
| p02991 |
n, m = list(map(int, input().split()))
graph1 = [[] for _ in range(n)]
graph2 = [[] for _ in range(n)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph1[u].append(v)
# def dfs(v0, v, k):
# if k == 0:
# graph2[v0].append((1, v))
# return
#
# for i in range(len(graph1[v])):
# dfs(v0, graph1[v][i][1], k-1)
#
# for i in range(n):
# dfs(i, i, 3)
# # print(graph1[i])
for i in range(n):
q = [(i, 3)]
idx = 0
while True:
if idx == len(q):
break
v, c = q[idx]
idx += 1
if c == 0:
graph2[i].append(v)
continue
for j in graph1[v]:
q.append((j, c-1))
# for i in range(n):
# print(i)
# for _, v in graph1[i]:
# print(" ->", v)
#
#
for i in range(n):
graph2[i] = list(set(graph2[i]))
# print()
# for i in range(n):
# print(graph2[i])
s, t = list(map(int, input().split()))
s -= 1
t -= 1
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# graph[node] = [(cost, to)]
inf = float('inf')
dist = [inf]*node
dist[start] = 0
heap = [(0,start)]
NextCost = 1
while heap:
cost,thisNode = heappop(heap)
for NextNode in graph[thisNode]:
dist_cand = dist[thisNode]+NextCost
if dist_cand < dist[NextNode]:
dist[NextNode] = dist_cand
heappush(heap,(dist[NextNode],NextNode))
return dist
# dist = [costs to nodes]
inf = float('inf')
dist = dijkstra(graph2, n, s)
if dist[t] == inf:
print((-1))
else:
print((dist[t]))
| n, m = list(map(int, input().split()))
graph1 = [[] for _ in range(n*3)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph1[u*3+0].append(v*3+1)
graph1[u*3+1].append(v*3+2)
graph1[u*3+2].append(v*3+0)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
s = s*3
t = t*3
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# graph[node] = [(cost, to)]
inf = float('inf')
dist = [inf]*node
dist[start] = 0
heap = [(0,start)]
NextCost = 1
while heap:
cost,thisNode = heappop(heap)
for NextNode in graph[thisNode]:
dist_cand = dist[thisNode]+NextCost
if dist_cand < dist[NextNode]:
dist[NextNode] = dist_cand
heappush(heap,(dist[NextNode],NextNode))
return dist
# dist = [costs to nodes]
inf = float('inf')
dist = dijkstra(graph1, n*3, s)
if dist[t] == inf:
print((-1))
else:
print((dist[t]//3))
| p02991 |
n, m = list(map(int, input().split()))
graph1 = [[] for _ in range(n*3)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph1[u*3+0].append(v*3+1)
graph1[u*3+1].append(v*3+2)
graph1[u*3+2].append(v*3+0)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
s = s*3
t = t*3
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# graph[node] = [(cost, to)]
inf = float('inf')
dist = [inf]*node
dist[start] = 0
heap = [(0,start)]
NextCost = 1
while heap:
cost,thisNode = heappop(heap)
for NextNode in graph[thisNode]:
dist_cand = dist[thisNode]+NextCost
if dist_cand < dist[NextNode]:
dist[NextNode] = dist_cand
heappush(heap,(dist[NextNode],NextNode))
return dist
# dist = [costs to nodes]
inf = float('inf')
dist = dijkstra(graph1, n*3, s)
if dist[t] == inf:
print((-1))
else:
print((dist[t]//3))
| n, m = list(map(int, input().split()))
graph1 = [[] for _ in range(n * 3)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph1[u * 3 + 0].append(v * 3 + 1)
graph1[u * 3 + 1].append(v * 3 + 2)
graph1[u * 3 + 2].append(v * 3 + 0)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
s = s * 3
t = t * 3
from heapq import heappush, heappop
def dijkstra(graph: list, n: int, start: int, INF: int = float('inf')) -> list:
# graph[node] = [(cost, to)]
dist = [INF] * n
num = [0] * n
dist[start] = 0
heap = [(0, start)]
while heap:
_, v_from = heappop(heap)
for v_to in graph[v_from]:
dist_cand = dist[v_from] + 1
if dist_cand < dist[v_to]:
dist[v_to] = dist_cand
heappush(heap, (dist[v_to], v_to))
return dist
# dist = [costs to nodes]
inf = float('inf')
dist = dijkstra(graph1, n * 3, s)
if dist[t] == inf:
print((-1))
else:
print((dist[t] // 3))
| p02991 |
import sys
from collections import deque
n,m = list(map(int,sys.stdin.readline().split()))
vertices = [[] for _ in range(n+1)]
jumpValue = [[-1,-1,-1] for _ in range(n+1)]
visited = set()
queue = []
temp = []
def bfs(arr,jump):
temp = []
for node in arr:
if jumpValue[node][(jump+1)%3]==-1:
queue.append([node,jump+1])
temp = temp+vertices[node]
return temp
for i in range(m):
a,b = list(map(int,sys.stdin.readline().split()))
vertices[a].append(b)
s,t = list(map(int,sys.stdin.readline().split()))
visited.add(s)
queue=deque()
queue.append([s,0])
while(len(queue)>0 ):
next=queue.popleft()
if jumpValue[next[0]][next[1]%3] == -1:
jumpValue[next[0]][next[1]%3] = next[1]
bfs(vertices[next[0]], next[1])
print((max(jumpValue[t][0]//3,-1)))
| import sys
from collections import deque
n,m = list(map(int,sys.stdin.readline().split()))
vertices = [[] for _ in range(n+1)]
jumpValue = [[-1,-1,-1] for _ in range(n+1)]
queue = []
def bfs(arr,jump):
for node in arr:
if jumpValue[node][(jump+1)%3]==-1:
queue.append([node,jump+1])
for i in range(m):
a,b = list(map(int,sys.stdin.readline().split()))
vertices[a].append(b)
s,t = list(map(int,sys.stdin.readline().split()))
queue=deque()
queue.append([s,0])
while(len(queue)>0 ):
next=queue.popleft()
if jumpValue[next[0]][next[1]%3] == -1:
jumpValue[next[0]][next[1]%3] = next[1]
bfs(vertices[next[0]], next[1])
if jumpValue[t][0]!=-1:
break
print((max(jumpValue[t][0]//3,-1))) | p02991 |
import sys
from io import StringIO
import unittest
import os
from collections import deque
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# 実装を行う関数
def resolve(test_def_name=""):
n, m = list(map(int, input().split()))
u_s = [list(map(int, input().split())) for i in range(m)]
s, t = list(map(int, input().split()))
point_s = [[] for i in range(n + 1)]
[point_s[u[0]].append(u[1]) for u in u_s]
# deq作成
ans = [999999999 for i in range(n + 1)]
bef = [999999999 for i in range(n + 1)]
ans[s] = 0
bef[s] = 0
que = deque()
que.appendleft(s)
# BFS開始
while len(que) is not 0:
now = que.pop()
# ケンケンパ
ken = point_s[now]
kenken = [point_s[k] for k in ken]
kenkenpo = [[point_s[k] for k in ken] for ken in kenken]
work_s = []
for kenken in kenkenpo:
for ken in kenken:
work_s += ken
work_s = set(work_s)
for work in work_s:
if ans[work] == 999999999:
ans[work] = ans[now] + 1
bef[work] = now
# キューに追加(先頭に追加するのでappendleft())
que.appendleft(work)
elif ans[work] > ans[now] + 1:
bef[work] = now
if ans[t] == 999999999:
print((-1))
return
aa = bef[t]
cnt = 1
for i in range(9999999):
if aa == s:
break
cnt += 1
aa = bef[aa]
print(cnt)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """4 4
1 2
2 3
3 4
4 1
1 3"""
output = """2"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """3 3
1 2
2 3
3 1
1 2"""
output = """-1"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """2 0
1 2"""
output = """-1"""
self.assertIO(test_input, output)
def test_input_4(self):
test_input = """6 8
1 2
2 3
3 4
4 5
5 1
1 4
1 5
4 6
1 6"""
output = """2"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| import sys
from io import StringIO
import unittest
import os
from collections import deque
import itertools
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# 実装を行う関数
def resolve(test_def_name=""):
n, m = list(map(int, input().split()))
u_s = [list(map(int, input().split())) for i in range(m)]
s, t = list(map(int, input().split()))
point_s = [[] for i in range(n + 1)]
[point_s[u[0]].append(u[1]) for u in u_s]
# deq作成
ans = [999999999 for i in range(n + 1)]
bef = [999999999 for i in range(n + 1)]
ans[s] = 0
bef[s] = 0
que = deque()
que.appendleft(s)
arrived1 = {}
arrived2 = {}
arrived3 = {}
# BFS開始
while len(que) is not 0:
now = que.pop()
# ケンケンパ
work_s = point_s[now]
ken = []
for work in work_s:
if arrived1.get(work, 0) == 0:
ken.append(work)
arrived1[work] = 1
# list(itertools.chain.from_iterable(l_2d))
work_s = [point_s[k] for k in ken]
work_s = list(itertools.chain.from_iterable(work_s))
kenken = []
for work in work_s:
if arrived2.get(work, 0) == 0:
kenken.append(work)
arrived2[work] = 1
work_s = [point_s[k] for k in kenken]
work_s = list(itertools.chain.from_iterable(work_s))
kenkenpa = []
for work in work_s:
if arrived3.get(work, 0) == 0:
kenkenpa.append(work)
arrived3[work] = 1
for ken in kenkenpa:
if ans[ken] == 999999999:
ans[ken] = ans[now] + 1
bef[ken] = now
# キューに追加(先頭に追加するのでappendleft())
que.appendleft(ken)
elif ans[ken] > ans[now] + 1:
bef[ken] = now
if ans[t] == 999999999:
print((-1))
return
aa = bef[t]
cnt = 1
for i in range(9999999):
if aa == s:
break
cnt += 1
aa = bef[aa]
print(cnt)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """4 4
1 2
2 3
3 4
4 1
1 3"""
output = """2"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """3 3
1 2
2 3
3 1
1 2"""
output = """-1"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """2 0
1 2"""
output = """-1"""
self.assertIO(test_input, output)
def test_input_4(self):
test_input = """6 8
1 2
2 3
3 4
4 5
5 1
1 4
1 5
4 6
1 6"""
output = """2"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| p02991 |
n, m = list(map(int, input().split()))
path_list = [[] for _ in range(n)]
for i in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
path_list[u].append(v)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
i = 0
dp = [[] for _ in range(3*n)]
dp[0].append(s)
while i < 3*n-1:
a = set()
for dot in dp[i]:
a |= set(path_list[dot])
if not -~i%3 and t in a:
print((-~i//3))
exit()
dp[i+1] = a
i += 1
print((-1)) | n, m = list(map(int, input().split()))
path_list = [[] for _ in range(n)]
for i in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
path_list[u].append(v)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
i = 0
dp = [set() for _ in range(3)]
dp[0].add(s)
while i < 3*n-1:
a = set()
for dot in dp[i%3]:
a |= set(path_list[dot])
dp[(i+1)%3] |= a
if t in dp[0]:
print((-~i//3))
exit()
i += 1
print((-1)) | p02991 |
import queue
MOD = 10**9 +7
INF = 10**9
def main():
n,m = list(map(int,input().split()))
V0 = [[] for _ in range(n)]
V1 = [[] for _ in range(n)]
V2 = [[] for _ in range(n)]
for _ in range(m):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
V0[u].append(v)
V1[u].append(v)
V2[u].append(v)
s,t = list(map(int,input().split()))
s -= 1
t -= 1
d0 = [-1]*n
d1 = [-1]*n
d2 = [-1]*n
d0[s] = 0
q = queue.Queue()
q.put([s,0])
while q.qsize():
p = q.get()
mod = p[1]
v = p[0]
if mod == 0:
for e in V0[v]:
if d1[e] == -1:
d1[e] = d0[v] + 1
q.put([e,1])
elif mod == 1:
for e in V1[v]:
if d2[e] == -1:
d2[e] = d1[v] + 1
q.put([e,2])
else:
for e in V2[v]:
if e == t:
print(((d2[v] + 1)//3))
exit()
if d0[e] == -1:
d0[e] = d2[v] + 1
q.put([e,0])
if d0[t] == -1:
print((-1))
if __name__=='__main__':
main()
| from collections import deque
MOD = 10**9 +7
INF = 10**9
def main():
n,m = list(map(int,input().split()))
V0 = [[] for _ in range(n)]
V1 = [[] for _ in range(n)]
V2 = [[] for _ in range(n)]
for _ in range(m):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
V0[u].append(v)
V1[u].append(v)
V2[u].append(v)
s,t = list(map(int,input().split()))
s -= 1
t -= 1
d0 = [-1]*n
d1 = [-1]*n
d2 = [-1]*n
d0[s] = 0
q = deque()
q.append((s,0))
while len(q):
v,mod = q.popleft()
if mod == 0:
for e in V0[v]:
if d1[e] == -1:
d1[e] = d0[v] + 1
q.append([e,1])
elif mod == 1:
for e in V1[v]:
if d2[e] == -1:
d2[e] = d1[v] + 1
q.append([e,2])
else:
for e in V2[v]:
if e == t:
print(((d2[v] + 1)//3))
exit()
if d0[e] == -1:
d0[e] = d2[v] + 1
q.append([e,0])
if d0[t] == -1:
print((-1))
if __name__=='__main__':
main()
| p02991 |
from collections import deque
inf = float('inf')
N, M = list(map(int, input().split()))
es = [[] for _ in range(N * 3)]
# 有向グラフ
for _ in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
# 0-indexed
es[u].append(v + N)
es[u + N].append(v + N * 2)
es[u + N * 2].append(v)
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dq = deque([(S, 0)])
dist = [inf] * (N * 3)
dist[S] = 0
while dq:
v, c = dq.popleft()
nc = c + 1
for nv in es[v]:
if nc < dist[nv]:
dist[nv] = nc
if v == T:
break
dq.append((nv, nc))
if dist[T] == inf:
print((-1))
else:
print((dist[T] // 3))
# print(dist)
| from collections import deque
inf = float('inf')
n, m = list(map(int, input().split()))
es = [[] for _ in range(n * 3)]
for _ in range(m):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
es[u].append(v + n)
es[u + n].append(v + n * 2)
es[u + n * 2].append(v)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
dq = deque()
dq.append(s)
can = False
dist = [inf] * (n * 3)
dist[s] = 0
while dq:
v = dq.popleft()
if v == t:
can = True
break
for nv in es[v]:
if dist[nv] == inf:
dq.append(nv)
dist[nv] = dist[v] + 1
if not can:
print((-1))
else:
print((dist[t] // 3))
| p02991 |
def bfs(g, N, s, t):
from collections import deque
dist = [-1] * (N * 3)
dist[s] = 0
dq = deque()
dq.append(s)
while dq:
v = dq.popleft()
d = dist[v]
for u in g[v]:
if ~dist[u]: continue
dist[u] = d + 1
if u == t:
return dist[t] // 3 # TLEしたので解を見つけたら即returnに変えた
dq.append(u)
return -1
def main():
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N * 3))
for _ in range(M):
u, v = (int(x) - 1 for x in input().split())
g[u].add(v + N)
g[u + N].add(v + N * 2)
g[u + N * 2].add(v)
S, T = (int(x) - 1 for x in input().split())
ans = bfs(g, N, S, T)
print(ans)
if __name__ == '__main__':
main()
| def main():
from collections import deque
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N * 3))
for _ in range(M):
u, v = (int(x) - 1 for x in input().split())
g[u].add(v + N)
g[u + N].add(v + N + N)
g[u + N + N].add(v)
S, T = (int(x) - 1 for x in input().split())
dist = [-1] * (N * 3)
dist[S] = 0
dq = deque()
dq.append(S)
while dq:
v = dq.popleft()
for u in g[v]:
if ~dist[u]: continue
dist[u] = dist[v] + 1
dq.append(u)
if dist[T] % 3:
print((-1))
return
print((dist[T] // 3))
if __name__ == '__main__':
main()
| p02991 |
from collections import deque
def main():
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
u, v = list(map(int, input().split()))
edges[u - 1].append(v - 1)
converted_edges = [[] for _ in range(N)]
for v, v_edge in enumerate(edges):
three_steps_nodes = []
for w in edges[v]:
for x in edges[w]:
for y in edges[x]:
three_steps_nodes.append(y)
converted_edges[v] = three_steps_nodes[:]
S, T = [int(x) - 1 for x in input().split()]
q = deque([(S, 0)])
nodes = [-1] * N
while q:
cv, count = q.popleft()
if cv == T:
if nodes[cv] == -1:
nodes[cv] = count
else:
nodes[cv] = min(nodes[cv], count)
else:
if nodes[cv] == -1 or count < nodes[cv]:
nodes[cv] = count
for u in converted_edges[cv]:
q.append((u, count + 1))
print((nodes[T]))
if __name__ == '__main__':
main()
| from collections import deque
def main():
N, M = list(map(int, input().split()))
edges = [[] for _ in range(3 * N)]
for _ in range(M):
u, v = [int(x) - 1 for x in input().split()]
edges[3 * u].append(3 * v + 1)
edges[3 * u + 1].append(3 * v + 2)
edges[3 * u + 2].append(3 * v)
S, T = [(int(x) - 1) * 3 for x in input().split()]
q = deque([(S, 0)])
nodes = [-1] * (3 * N)
while q:
cv, count = q.popleft()
if cv == T:
nodes[cv] = count if nodes[cv] == -1 else min(nodes[cv], count)
else:
if nodes[cv] == -1 or count < nodes[cv]:
nodes[cv] = count
for u in edges[cv]:
q.append((u, count + 1))
print((nodes[T] // 3 if nodes[cv] != -1 else -1))
if __name__ == '__main__':
main()
| p02991 |
#coding: utf-8
from collections import deque
N, M = list(map(int, input().split()))
graph = {i:[] for i in range(1, N+1)}
for i in range(M):
u, v = list(map(int, input().split()))
graph[u].append(v)
# graph[v].append(u)
S, T = list(map(int, input().split()))
queue = deque([[graph[S][i], 0] for i in range(len(graph[S]))])
cnt = 0
visited = [False for _ in range(N)]
while queue:
# print(len(queue))
now = queue.popleft()
# print(now)
now[1] += 1
# if visited[now[0]-1]:
# continue
if now[1] >= 10**6:
break
if now[1] % 3 == 0:
# print("visited", now[0])
visited[now[0]-1] = True
if now[0] == T:
print((now[1] // 3))
exit()
for i in range(len(graph[now[0]])):
queue.append([graph[now[0]][i], now[1]])
else:
for i in range(len(graph[now[0]])):
queue.append([graph[now[0]][i], now[1]])
print((-1))
| from sys import stdin
from collections import deque
def main():
#入力
readline=stdin.readline
n,m=list(map(int,readline().split()))
G=[[] for _ in range(n*3)]
for i in range(m):
a,b=[int(x)-1 for x in readline().split()]
for j in range(3):
G[3*a+j].append(3*b+(j+1)%3)
s,t=[int(x)-1 for x in readline().split()]
s*=3
t*=3
#bfs
d=deque([s])
flags=[-1]*(3*n)
flags[s]=0
while len(d)>0:
now=d.popleft()
for nex in G[now]:
if flags[nex]==-1:
flags[nex]=flags[now]+1
d.append(nex)
print((flags[t]//3))
if __name__=="__main__":
main()
| p02991 |
from collections import defaultdict
import sys
input = sys.stdin.readline
def main():
node_num, edge_num = list(map(int, input().split()))
graph_data = defaultdict(set)
abcde = [list(map(int, input().split())) for i in range(edge_num)]
for i in range(edge_num):
a, b = abcde[i]
graph_data[a].add(b)
start, goal = list(map(int, input().split()))
visit_flg = [0] * (node_num + 1)
visit_flg[start] = 1
now_set = set()
now_set.add(start)
next_set = set()
ans = 0
while len(now_set) > 0:
ans += 1
if visit_flg[goal]:
break
for now_node in now_set:
search_now_set = set()
search_now_set.add(now_node)
search_next_set = set()
for i in range(3):
for search_now_node in search_now_set:
search_next_set |= graph_data[search_now_node]
search_now_set = search_next_set
search_next_set = set()
for ele_check in search_now_set:
if visit_flg[ele_check]:
continue
else:
visit_flg[ele_check] = 1
next_set.add(ele_check)
if visit_flg[goal]:
break
if visit_flg[goal]:
break
now_set = next_set
next_set = set()
if visit_flg[goal]:
print(ans)
else:
print((-1))
if __name__ == '__main__':
main() | from collections import defaultdict
import sys
input = sys.stdin.readline
def main():
node_num, edge_num = list(map(int, input().split()))
graph_data = defaultdict(set)
abcde = [list(map(int, input().split())) for i in range(edge_num)]
for i in range(edge_num):
a, b = abcde[i]
graph_data[a].add(b)
start, goal = list(map(int, input().split()))
visit_flg = [0] * (node_num + 1)
visit_flg2 = [0] * (node_num + 1)
visit_flg3 = [0] * (node_num + 1)
visit_flg[start] = 1
now_set = set()
now_set.add(start)
next_set = set()
ans = 0
while len(now_set) > 0:
ans += 1
if visit_flg[goal]:
break
for now_node in now_set:
search_now_set = set()
search_now_set.add(now_node)
search_next_set = set()
for i in range(3):
for search_now_node in search_now_set:
if i == 1 and visit_flg2[search_now_node]:
continue
elif i == 1:
visit_flg2[search_now_node] = 1
if i == 2 and visit_flg3[search_now_node]:
continue
elif i == 2:
visit_flg3[search_now_node] = 1
search_next_set |= graph_data[search_now_node]
search_now_set = search_next_set
search_next_set = set()
for ele_check in search_now_set:
if visit_flg[ele_check]:
continue
else:
visit_flg[ele_check] = 1
next_set.add(ele_check)
if visit_flg[goal]:
break
if visit_flg[goal]:
break
now_set = next_set
next_set = set()
if visit_flg[goal]:
print(ans)
else:
print((-1))
if __name__ == '__main__':
main()
| p02991 |
#!/usr/bin/env python
import sys
def getVertex(i,e):
v= set()
for v1 in e[i]:
for v2 in e[v1]:
for v3 in e[v2]: v.add( v3 )
#
return v
#
n,m = [ int(x) for x in sys.stdin.readline().split() ]
e = { i:[] for i in range(n) }
for _ in range(m):
u,v = [ int(x) for x in sys.stdin.readline().split() ]
e[u-1].append( v-1 )
s,t = [ int(x)-1 for x in sys.stdin.readline().split() ]
#
hop= 0
now = {s}
visit = {s}
while True:
hop+= 1
n= set()
for i in now:
n |= getVertex(i,e) - visit
#
if t in n: break
if not n:
hop= -1
break
now = n
visit|= n
#
print( hop )
| #!/usr/bin/env python
import sys
v1mask= set()
v2mask= set()
def getVertex(i,e):
global v1mask, v2mask
v= set()
for v1 in e[i]:
if v1 in v1mask: continue
v1mask.add( v1 )
for v2 in e[v1]:
if v2 in v2mask: continue
v2mask.add( v2 )
for v3 in e[v2]: v.add( v3 )
#
return v
#
n,m = [ int(x) for x in sys.stdin.readline().split() ]
e = { i:[] for i in range(n) }
for _ in range(m):
u,v = [ int(x) for x in sys.stdin.readline().split() ]
e[u-1].append( v-1 )
s,t = [ int(x)-1 for x in sys.stdin.readline().split() ]
#
hop= 0
now = {s}
visit = {s}
while True:
hop+= 1
n= set()
for i in now:
n |= getVertex(i,e) - visit
if t in n: break
#
if t in n: break
if not n:
hop= -1
break
now = n
visit|= n
#
print( hop )
| p02991 |
from collections import deque
n, m = list(map(int, input().split()))
graph = [set([]) for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, input().split()))
graph[u].add(v)
graph3 = [set([]) for _ in range(n+1)]
for i, g in enumerate(graph):
if i == 0:
continue
graph2 = set([])
for r in g:
graph2 |= graph[r]
for r in graph2:
graph3[i] |= graph[r]
s, t = list(map(int, input().split()))
q = deque([s])
visited = [False] * (n+1)
visited[s] = True
dist = [-1] * (n+1)
dist[s] = 0
while q:
now = q.popleft()
for i in graph3[now]:
if visited[i]:
continue
if i == now:
continue
q.append(i)
visited[i] = True
dist[i] = dist[now] + 1
print((dist[t]))
| from collections import deque
n, m = list(map(int, input().split()))
graph = [[[] for _ in range(3)] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, input().split()))
graph[u][0].append([v, 1])
graph[u][1].append([v, 2])
graph[u][2].append([v, 0])
s, t = list(map(int, input().split()))
q = deque([[s, 0]])
visited = [[False] * 3 for _ in range(n+1)]
visited[s][0] = True
dist = [[-3] * 3 for _ in range(n+1)]
dist[s][0] = 0
while q:
num, cnt = q.popleft()
for i, j in graph[num][cnt]:
if visited[i][j]:
continue
q.append([i, j])
visited[i][j] = True
dist[i][j] = dist[num][cnt] + 1
print((dist[t][0]//3))
| p02991 |
from collections import deque
n, m = list(map(int, input().split()))
graph = [[[] for _ in range(3)] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, input().split()))
graph[u][0].append([v, 1])
graph[u][1].append([v, 2])
graph[u][2].append([v, 0])
s, t = list(map(int, input().split()))
q = deque([[s, 0]])
visited = [[False] * 3 for _ in range(n+1)]
visited[s][0] = True
dist = [[-3] * 3 for _ in range(n+1)]
dist[s][0] = 0
while q:
num, cnt = q.popleft()
for i, j in graph[num][cnt]:
if visited[i][j]:
continue
q.append([i, j])
visited[i][j] = True
dist[i][j] = dist[num][cnt] + 1
print((dist[t][0]//3))
| from collections import deque
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n+1)]
for _ in range(m):
u, v = list(map(int, input().split()))
graph[u].append(v)
s, t = list(map(int, input().split()))
dist = [[-3] * 3 for _ in range(n+1)]
dist[s][0] = 0
q = deque([(s, 0)])
while q:
now, c = q.popleft()
ne = (c+1) % 3
for node in graph[now]:
if dist[node][ne] != -3:
continue
dist[node][ne] = dist[now][c] + 1
q.append((node, ne))
print((dist[t][0] // 3))
| p02991 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N, M = rl()
E = defaultdict(list)
for i in range(M):
u, v = rl()
E[u-1].append(v-1)
#E[v-1].append(u-1)
S, T = rl()
S -= 1
T -= 1
dp = [[float('inf')]*3 for i in range(N)]
def dfs(n, d):
for m in E[n]:
r = (d+1)%3
if dp[m][r] > d+1:
dp[m][r] = d+1
dfs(m, d+1)
dfs(S, 0)
if dp[T][0] != float('inf'):
print((dp[T][0]//3))
else:
print((-1))
| import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N, M = rl()
E = defaultdict(list)
for i in range(M):
u, v = rl()
E[u-1].append(v-1)
S, T = rl()
S -= 1
T -= 1
dp = [[float('inf')]*3 for i in range(N)]
heap = []
heappush(heap, (0, S, 0))
while heap:
d, n, r = heappop(heap)
if n == T and r == 0:
continue
#if dp[n][r] != d:
# continue
nr = (d+1)%3
for m in E[n]:
if dp[m][nr] > d+1:
dp[m][nr] = d+1
heappush(heap, (d+1, m, nr))
if dp[T][0] != float('inf'):
print((dp[T][0]//3))
else:
print((-1))
| p02991 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N, M = rl()
E = defaultdict(list)
for i in range(M):
u, v = rl()
E[u-1].append(v-1)
S, T = rl()
S -= 1
T -= 1
dp = [[float('inf')]*3 for i in range(N)]
heap = []
heappush(heap, (0, S, 0))
while heap:
d, n, r = heappop(heap)
if n == T and r == 0:
continue
#if dp[n][r] != d:
# continue
nr = (d+1)%3
for m in E[n]:
if dp[m][nr] > d+1:
dp[m][nr] = d+1
heappush(heap, (d+1, m, nr))
if dp[T][0] != float('inf'):
print((dp[T][0]//3))
else:
print((-1))
| import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)
N, M = rl()
E = defaultdict(list)
for i in range(M):
u, v = rl()
E[u-1].append(v-1)
S, T = rl()
S -= 1
T -= 1
queue = deque()
queue.append((S,0,0))
visited = set()
while queue:
n, r, d = queue.popleft()
if n == T and r == 0:
print((d//3))
exit()
nr = (r+1)%3
for m in E[n]:
if (m, nr) in visited: continue
visited.add((m, nr))
queue.append((m, nr, d+1))
print((-1)) | p02991 |
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def make_adjlist_d(n, edges):
res = [[] for _ in range(n+1)]
for edge in edges:
res[edge[0]].append(edge[1])
return res
class UnionFind:
def __init__(self, n):
#親要素のノード番号を格納 xが根のとき-(サイズ)を格納
self.par = [-1 for i in range(n)]
self.n = n
def find(self, x):
#根ならその番号を返す
if self.par[x] < 0:
return x
else:
#親の親は親
self.par[x] = self.find(self.par[x])
return self.par[x]
def is_same(self, x, y):
#根が同じならTrue
return self.find(x) == self.find(y)
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
#木のサイズを比較し、小さいほうから大きいほうへつなぐ
if self.par[x] > self.par[y]:
x, y = y, x
self.par[x] += self.par[y]
self.par[y] = x
def size(self, x):
return -self.par[self.find(x)]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.par) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __repr__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = NMI()
edges = [NLI() for _ in range(M)]
S, T = NMI()
tree = make_adjlist_d(N, edges)
tree = [set(tr) for tr in tree]
uf = UnionFind(N+1)
for edge in edges:
uf.unite(edge[0], edge[1])
if not uf.is_same(S, T):
print((-1))
exit()
tree2 = [[] for _ in range(N+1)]
for i in uf.members(S):
gotos = tree[i]
for goto in gotos:
tree2[i] += tree[goto]
tree2 = [set(tr) for tr in tree2]
tree3 = [[] for _ in range(N+1)]
for i in uf.members(S):
gotos = tree2[i]
for goto in gotos:
tree3[i] += tree[goto]
tree3 = [set(tr) for tr in tree3]
stack = deque()
stack.append(S)
seen = [-1] * (N+1)
seen[S] = 0
while stack:
now = stack.popleft()
now_step = seen[now]
for goto in tree3[now]:
if seen[goto] >= 0:
continue
stack.append(goto)
seen[goto] = now_step + 1
print((seen[T]))
if __name__ == "__main__":
main() | import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def make_adjlist_d(n, edges):
res = [[] for _ in range(n+1)]
for edge in edges:
res[edge[0]].append(edge[1])
return res
def main():
N, M = NMI()
edges = [NLI() for _ in range(M)]
S, T = NMI()
tree = [[] for _ in range(3*N+1)]
for e in edges:
tree[e[0]].append(e[1]+N)
tree[e[0]+N].append(e[1]+2*N)
tree[e[0]+2*N].append(e[1])
stack = deque()
stack.append(S)
seen = [-1] * (3*N+1)
seen[S] = 0
while stack:
now = stack.popleft()
now_step = seen[now]
for goto in tree[now]:
if seen[goto] >= 0:
continue
stack.append(goto)
seen[goto] = now_step + 1
print((seen[T]//3))
if __name__ == "__main__":
main() | p02991 |
import sys
from collections import Counter, deque, defaultdict
from itertools import accumulate, permutations, combinations, takewhile, compress, cycle
from functools import reduce
from math import ceil, floor, log10, factorial
import math
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
INF = float('inf')
# N = int(input())
# A = [int(x) for x in input().split()]
# A = [int(input()) for _ in range(N)]
# dp = [[0] * 100 for _ in range(100)]
# dp = defaultdict(lambda: float('inf'))
# print('hoge', file=sys.stderr)
N, M = [int(x) for x in input().split()]
# E = {set() for _ in range(N + 1)}
E = defaultdict(lambda: set())
for i in range(M):
u, v = [int(x) for x in input().split()]
u -= 1
v -= 1
E[3 * u].add(3 * v + 1)
E[3 * u + 1].add(3 * v + 2)
E[3 * u + 2].add(3 * v)
S, T = [int(x) for x in input().split()]
S = 3 * (S - 1)
T = 3 * (T - 1)
def bfs(e, start, end):
open = {start}
w = dict()
w[start] = 0
while len(open) != 0:
target = min(open, key=lambda x: w[x])
open.remove(target)
for next in E[target]:
if not next in w:
open.add(next)
w[next] = w[target] + 1
return w[end] // 3 if end in w else -1
print((bfs(E, S, T)))
| import sys
from collections import Counter, deque, defaultdict
from itertools import accumulate, permutations, combinations, takewhile, compress, cycle
from functools import reduce
from math import ceil, floor, log10, factorial
import math
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
INF = float('inf')
# N = int(input())
# A = [int(x) for x in input().split()]
# A = [int(input()) for _ in range(N)]
# dp = [[0] * 100 for _ in range(100)]
# dp = defaultdict(lambda: float('inf'))
# print('hoge', file=sys.stderr)
N, M = [int(x) for x in input().split()]
# E = {set() for _ in range(N + 1)}
E = defaultdict(lambda: set())
for i in range(M):
u, v = [int(x) for x in input().split()]
u -= 1
v -= 1
E[3 * u].add(3 * v + 1)
E[3 * u + 1].add(3 * v + 2)
E[3 * u + 2].add(3 * v)
S, T = [int(x) for x in input().split()]
S = 3 * (S - 1)
T = 3 * (T - 1)
def bfs(e, start, end):
open = deque([start])
w = dict()
w[start] = 0
while len(open) != 0:
target = open.popleft()
for next in E[target]:
if not next in w:
open.append(next)
w[next] = w[target] + 1
return w[end] // 3 if end in w else -1
print((bfs(E, S, T)))
| p02991 |
import sys, collections
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
son = [[] for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
son[u-1].append(v-1)
S, T = list(map(int, input().split()))
graphB = [set() for i in range(N)]
q = collections.deque()
for i in range(N):
q.append((0, i))
pathi = set()
while q:
cost, now = q.popleft()
if cost <= 1:
for s in son[now]: q.append((cost+1, s))
elif cost == 2:
for s in son[now]: pathi |= {s}
graphB[i] = pathi
visited = [-1] * N
q.append((0, S-1))
while q:
cost, now = q.popleft()
if visited[now] < 0:
visited[now] = cost
for s in graphB[now]:
if visited[s] < 0: q.append((cost + 1, s))
print((visited[T-1]))
return 0
if __name__ == "__main__":
solve() | import sys, collections
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
son = [[] for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
son[u-1].append(v-1)
S, T = list(map(int, input().split()))
graphB = [[] for i in range(N)]
for i in range(N):
for s1 in son[i]:
for s2 in son[s1]:
for s3 in son[s2]: graphB[i].append(s3)
q = collections.deque()
visited = [-1] * N
q.append((0, S-1))
while q:
cost, now = q.popleft()
if visited[now] == -1:
visited[now] = cost
for s in graphB[now]:
if visited[s] == -1: q.append((cost + 1, s))
print((visited[T-1]))
return 0
if __name__ == "__main__":
solve() | p02991 |
import sys, collections
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
son = [[] for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
son[u-1].append(v-1)
S, T = list(map(int, input().split()))
graphB = [set() for i in range(N)]
for i in range(N):
for s1 in son[i]:
for s2 in son[s1]:
graphB[i] |= set(son[s2])
q = collections.deque()
visited = [-1] * N
q.append((0, S-1))
while q:
cost, now = q.popleft()
if visited[now] == -1:
visited[now] = cost
for s in graphB[now]:
if visited[s] == -1: q.append((cost + 1, s))
print((visited[T-1]))
return 0
if __name__ == "__main__":
solve() | import sys, collections
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
son = [[] for i in range(N)]
for i in range(M):
u, v = list(map(int, input().split()))
son[u-1].append(v-1)
S, T = list(map(int, input().split()))
dist = [[-1, -1, -1] for i in range(N)]
que = collections.deque()
que.append((0, S-1, 0)) #k回目の移動, 場所, mod
while que:
cost, now, mod = que.popleft()
if dist[now][mod] == -1:
dist[now][mod] = cost
if mod == 0:
for s in son[now]:
if dist[s][1] == -1: que.append((cost + 1, s, 1))
else:
for s in son[now]:
if dist[s][(mod + 1) % 3] == -1: que.append((cost, s, (mod + 1) % 3))
print((dist[T-1][0]))
return 0
if __name__ == "__main__":
solve() | p02991 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.