input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,m=list(map(int,input().split()))
visited = [[False,False,False] for _ in range(n)]
ren = [[0]*n for _ in range(n)]
for i in range(m):
u,v = list(map(int,input().split()))
ren[u-1][v-1] = 1
s,t = list(map(int,input().split()))
Q = [(s,0)]
visited[s-1][2]=True
ans = -1
while len(Q)>0:
curs,curcount = Q.pop(0)
if curs == t:
ans = curcount
break
for i in range(n):
if ren[curs-1][i] and not visited[i][0]:
visited[i][0]=True
for j in range(n):
if ren[i][j] and not visited[j][1]:
visited[j][1]=True
for k in range(n):
if ren[j][k] and not visited[k][2]:
visited[k][2]=True
Q.append((k+1,curcount+1))
print(ans) | n,m=list(map(int,input().split()))
visited = [[False,False,False] for _ in range(n)]
ren = [[] for _ in range(n)]
for i in range(m):
u,v = list(map(int,input().split()))
ren[u-1].append(v)
s,t = list(map(int,input().split()))
Q = [(s,0)]
visited[s-1][2]=True
ans = -1
while len(Q)>0:
curs,curcount = Q.pop(0)
if curs == t:
ans = curcount
break
for i in ren[curs-1]:
if not visited[i-1][0]:
visited[i-1][0]=True
for j in ren[i-1]:
if not visited[j-1][1]:
visited[j-1][1]=True
for k in ren[j-1]:
if not visited[k-1][2]:
visited[k-1][2]=True
Q.append((k,curcount+1))
print(ans)
| p02991 |
import copy
import sys
input = sys.stdin.readline
n, m = list(map(int,input().split()))
edge = []
graph = [[] for i in range(n+1)]
for i in range(m):
edge.append(list(map(int,input().split())))
graph[edge[-1][0]].append(edge[-1][1])
s, g = list(map(int,input().split()))
INF = 10**18
ans = [[INF, INF, INF] for i in range(n+1)]
q = [s]
d = 0
while q:
nq = []
d += 1
p = d % 3
for cf in q:
for ct in graph[cf]:
if ans[ct][p] == INF:
ans[ct][p] = d
nq.append(ct)
q = copy.deepcopy(nq)
if ans[g][0] == INF:
print((-1))
else:
print((ans[g][0]//3)) | import copy
import sys
input = sys.stdin.readline
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, g = list(map(int,input().split()))
INF = 10**7
ans = [[INF, INF, INF] for i in range(n+1)]
q = [s]
d = 0
while q:
nq = []
d += 1
p = d % 3
for cf in q:
for ct in graph[cf]:
if ans[ct][p] == INF:
ans[ct][p] = d
nq.append(ct)
q = copy.deepcopy(nq)
if ans[g][0] == INF:
print((-1))
else:
print((ans[g][0]//3)) | p02991 |
import copy
import sys
input = sys.stdin.readline
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, g = list(map(int,input().split()))
INF = 10**7
ans = [[INF, INF, INF] for i in range(n+1)]
q = [s]
d = 0
while q:
nq = []
d += 1
p = d % 3
for cf in q:
for ct in graph[cf]:
if ans[ct][p] == INF:
ans[ct][p] = d
nq.append(ct)
q = copy.deepcopy(nq)
if ans[g][0] == INF:
print((-1))
else:
print((ans[g][0]//3)) | # 頂点を3回ずつに持つ (x歩目の着地）
# 最短路
import sys
input = sys.stdin.readline
N,M = list(map(int,input().split()))
if M == 0:
print((-1))
exit()
edge = [[] for _ in range(N+1)]
for _ in range(M):
u,v = list(map(int,input().split()))
edge[u].append(v)
S,T = list(map(int,input().split()))
INF = 10 ** 9
dist = [[INF,INF,INF] for _ in range(N+1)]
d = 0
q = [S]
while q:
d += 1
r = d % 3
qq = []
for u in q:
for v in edge[u]:
if dist[v][r] == INF:
dist[v][r] = d
qq.append(v)
q = qq
d = dist[T][0]
answer = -1 if d == INF else d // 3
print(answer)
| p02991 |
import sys
sys.setrecursionlimit(100000)
N, M = map(int, input().split())
UV = [list(map(int, input().split())) for _ in range(M)]
S, T = map(int, input().split())
if 0 == M:
print(-1)
exit()
s, t = S - 1, T - 1
graph = [[] for _ in range(N)]
for u, v in UV:
graph[u - 1] += [v - 1]
INF = 10 ** 12
cost = [[INF, INF, INF] for _ in range(N)]
def print_cost(cost):
for line in cost:
for cell in line:
print(" INF" if cell == INF else " {:4d}".format(cell), end="")
print()
print()
def dfs(graph, cost, c, d):
if cost[c][d % 3] <= d:
return
cost[c][d % 3] = d
#print_cost(cost)
for n in graph[c]:
dfs(graph, cost, n, d + 1)
dfs(graph, cost, s, 0)
if INF == cost[t][0]:
print(-1)
else:
print(cost[t][0] // 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()))
if 0 == M:
print((-1))
exit()
graph = [set() for _ in range(N)]
for u, v in UV:
graph[u - 1] |= {v - 1}
INF = 10 ** 12
depths = [[INF, INF, INF] for _ in range(N)]
def bfs(start, end):
depth = 0
nodes = {start}
while nodes:
if (0 == depth % 3) and (end in nodes):
return depth // 3
next_nodes = set()
for node in nodes:
if depths[node][depth % 3] <= depth:
continue
depths[node][depth % 3] = depth
next_nodes |= graph[node]
nodes = next_nodes
depth += 1
return -1
print((bfs(S - 1, T - 1)))
| p02991 |
import sys
from collections import deque
sys.setrecursionlimit(10**6)
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(M):
u, v = list(map(int, input().split()))
G[u-1].append(v-1)
S, T = list(map(int, input().split()))
S, T = S-1, T-1
q = deque()
q.append(S)
cnt = 0
cnt_k = 0
visited = [False] * N
visited[S] = True
while len(q) > 0:
cnt += 1
if cnt % 3 == 0:
cnt_k += 1
next_ = set()
while len(q) > 0:
n0 = q.pop()
for n1 in G[n0]:
if cnt % 3 == 0:
if n1 == T:
return cnt_k
if visited[n1]:
continue
visited[n1] = True
next_.add(n1)
q = deque()
q.extend(list(next_))
return -1
if __name__ == '__main__':
print((main()))
| import sys
from collections import deque
def main():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
G = [[] for _ in range(3*N)]
for _ in range(M):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
G[3*u].append(3*v+1)
G[3*u+1].append(3*v+2)
G[3*u+2].append(3*v)
S, T = list(map(int, input().split()))
S, T = 3*(S-1), 3*(T-1)
cnt = 0
q = deque()
q.append(S)
visited = [False] * (3*N)
visited[S] = True
while len(q) > 0:
q_ = deque()
cnt += 1
while len(q) > 0:
n = q.pop()
for m in G[n]:
if visited[m]:
continue
if m == T:
return cnt // 3
visited[m] = True
q_.append(m)
q = q_
return -1
if __name__ == '__main__':
print((main()))
| p02991 |
import sys
sys.setrecursionlimit(200000)
def main():
INF = float("inf")
input = sys.stdin.readline
N, M = list(map(int,input().split()))
G = [[[],[],[]] for k in range(N)]
for k in range(M):
u, v = list(map(int,input().split()))
u -= 1
v -= 1
G[u][0] += [v]
G[u][1] += [v]
G[u][2] += [v]
S, T = list(map(int,input().split()))
S -= 1
T -= 1
D1 = [[INF,INF,INF] for k in range(N)]
D1[S][0] = 0
def dfs1(now):
for tsugi in G[now][1]:
if D1[tsugi][1] > D1[now][0] + 1:
D1[tsugi][1] = D1[now][0] + 1
dfs2(tsugi)
def dfs2(now):
for tsugi in G[now][2]:
if D1[tsugi][2] > D1[now][1] + 1:
D1[tsugi][2] = D1[now][1] + 1
dfs3(tsugi)
def dfs3(now):
for tsugi in G[now][2]:
if D1[tsugi][0] > D1[now][2] + 1:
D1[tsugi][0] = D1[now][2] + 1
dfs1(tsugi)
dfs1(S)
if D1[T][0]%3 == 0:
print((D1[T][0]//3))
else:
print((-1))
if __name__ == '__main__':
main()
| import sys
def main():
INF = float("inf")
input = sys.stdin.readline
N, M = list(map(int,input().split()))
G = [[] for k in range(N)]
for k in range(M):
u, v = list(map(int,input().split()))
u -= 1
v -= 1
G[u] += [v]
S, T = list(map(int,input().split()))
S -= 1
T -= 1
D = [[INF,INF,INF] for k in range(N)]
D[S][0] = 0
Q = [[S,0]]
while len(Q) > 0:
ima = Q[0][0]
k = Q[0][1]
Q.pop(0)
for tsugi in G[ima]:
if D[tsugi][(k+1)%3] != INF:
pass
else:
D[tsugi][(k+1)%3] = D[ima][k] + 1
Q.append([tsugi,(k+1)%3])
if D[T][0] == INF or D[T][0]%3 != 0:
print((-1))
else:
print((D[T][0]//3))
if __name__ == '__main__':
main()
| p02991 |
from collections import defaultdict
from queue import Queue
n, m = list(map(int, input().split()))
MX = int(1e6)
edge = defaultdict(set)
edge2 = defaultdict(set)
kenedge = defaultdict(set)
dist = [MX for i in range(n)]
reached = [False for i in range(n)]
for loop in range(m):
a, b = list(map(int, input().split()))
edge[a-1].add(b-1)
for i in range(n):
step1 = set()
for ii in edge[i]:
edge2[i] |= edge[ii]
for i in range(n):
step2 = set()
for ii in edge2[i]:
kenedge[i] |= edge[ii]
s, t = list(map(int, input().split()))
s = s-1
t = t-1
dist[s] = 0
q = Queue()
q.put(s)
while not q.empty():
node = q.get()
reached[node] = True
for next_node in kenedge[node]:
if not reached[next_node]: q.put(next_node)
dist[next_node] = min(dist[next_node], dist[node] + 1)
if dist[t] == MX:
print((-1))
else:
print((dist[t]))
| from collections import defaultdict
from queue import Queue
n, m = list(map(int, input().split()))
MX = int(1e6)
edge = defaultdict(set)
dist = [[MX, MX, MX] for i in range(n)]
reached = [[False, False, False] for i in range(n)]
for loop in range(m):
a, b = list(map(int, input().split()))
edge[a-1].add(b-1)
s, t = list(map(int, input().split()))
s = s-1
t = t-1
dist[s][0] = 0
q = Queue()
q.put((s, 0))
while not q.empty():
node, step = q.get()
next_step = (step + 1) % 3
reached[node][step] = True
for next_node in edge[node]:
if not reached[next_node][next_step]: q.put((next_node, next_step))
if step == 2:
dist[next_node][next_step] = min(dist[next_node][next_step], dist[node][step] + 1)
else:
dist[next_node][next_step] = min(dist[next_node][next_step], dist[node][step])
if dist[t][0] == MX:
print((-1))
else:
print((dist[t][0]))
| p02991 |
from collections import defaultdict
from queue import Queue
n, m = list(map(int, input().split()))
MX = int(1e6)
edge = defaultdict(set)
dist = [[MX, MX, MX] for i in range(n)]
reached = [[False, False, False] for i in range(n)]
for loop in range(m):
a, b = list(map(int, input().split()))
edge[a-1].add(b-1)
s, t = list(map(int, input().split()))
s = s-1
t = t-1
dist[s][0] = 0
q = Queue()
q.put((s, 0))
while not q.empty():
node, step = q.get()
next_step = (step + 1) % 3
reached[node][step] = True
for next_node in edge[node]:
if reached[next_node][next_step]: continue
q.put((next_node, next_step))
if step == 2:
dist[next_node][next_step] = min(dist[next_node][next_step], dist[node][step] + 1)
else:
dist[next_node][next_step] = min(dist[next_node][next_step], dist[node][step])
if dist[t][0] == MX:
print((-1))
else:
print((dist[t][0]))
| from collections import defaultdict
from queue import Queue
n, m = list(map(int, input().split()))
MX = int(1e6)
edge = defaultdict(set)
dist = [[MX, MX, MX] for i in range(n)]
reached = [[False, False, False] for i in range(n)]
for loop in range(m):
a, b = list(map(int, input().split()))
edge[a-1].add(b-1)
s, t = list(map(int, input().split()))
s = s-1
t = t-1
dist[s][0] = 0
q = Queue()
q.put((s, 0))
while not q.empty():
node, step = q.get()
next_step = (step + 1) % 3
for next_node in edge[node]:
if reached[next_node][next_step]: continue
q.put((next_node, next_step))
reached[next_node][next_step] = True
if step == 2:
dist[next_node][next_step] = min(dist[next_node][next_step], dist[node][step] + 1)
else:
dist[next_node][next_step] = min(dist[next_node][next_step], dist[node][step])
if dist[t][0] == MX:
print((-1))
else:
print((dist[t][0]))
| p02991 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph: list, start, INF=float('inf')) -> list:
n = len(graph)
dist = [INF] * n
visited = [False] * n
dist[start] = 0
que = [(0, start)]
while que:
cost, cur = heappop(que)
if visited[cur]:
continue
visited[cur] = True
for edgecost, nextnode in graph[cur]:
nextcost = cost + edgecost
if nextcost < dist[nextnode]:
dist[nextnode] = nextcost
heappush(que, (nextcost, nextnode))
return dist
n, m = li()
edges = []
ins = [[] for _ in range(n)]
ots = [[] for _ in range(n)]
for _ in range(m):
u,v = li_()
ins[v].append(u)
ots[u].append(v)
edges.append((u, v))
graph = [set() for _ in range(n)]
for ui, vi in edges:
for st in ins[ui]:
for to in ots[vi]:
graph[st].add((1,to))
s, t = li_()
INF = 10**8+1
dist = dijkstra(graph, s, INF)
print((-1 if dist[t] == INF else dist[t])) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph: list, start, INF=float('inf')) -> list:
n = len(graph)
dist = [INF ] *n
visited = [False ] *n
dist[start] = 0
que = [(0, start)]
while que:
cost, cur = heappop(que)
if visited[cur]:
continue
visited[cur] = True
for nextnode, edgecost in graph[cur]:
nextcost = cost + edgecost
if nextcost < dist[nextnode]:
dist[nextnode] = nextcost
heappush(que, (nextcost, nextnode))
return dist
n, m = li()
graph = [[] for _ in range(3*n)]
for _ in range(m):
u, v = li_()
for i in range(3):
graph[i*n + u].append([(i+1)%3 * n + v, 1])
s, t = li_()
INF = 1<<62
dist = dijkstra(graph, s, INF)
print((-1 if dist[t] == INF else dist[t] // 3))
| p02991 |
from queue import Queue
N, M = list(map(int, input().split()))
INF = -1
dist = [[INF]*3 for _ in range(N)]
vector = [[0]*N for _ in range(N)]
for i in range(M):
graf1, graf2 = list(map(int, input().split()))
vector[graf1-1][graf2-1] = 1
S, T = list(map(int, input().split()))
S, T = S-1, T-1
# BFS
dist[S][0] = 0
q = Queue(3*N+1)
q.put((S, 0))
while not q.empty():
v, l = q.get()
for i in range(N):
if vector[v][i] != 1:
continue
new_l = (l+1)%3
if dist[i][new_l] != INF:
continue
dist[i][new_l] = dist[v][l] + 1
q.put((i, new_l))
ans = dist[T][0]
if ans == INF:
print("-1")
else:
print((int(ans/3))) | from queue import Queue
N, M = list(map(int, input().split()))
INF = -1
dist = [[INF]*3 for _ in range(N)]
vector = [[] for _ in range(N)]
for i in range(M):
graf1, graf2 = list(map(int, input().split()))
vector[graf1-1].append(graf2-1)
S, T = list(map(int, input().split()))
S, T = S-1, T-1
# BFS
dist[S][0] = 0
q = Queue(3*N+1)
q.put((S, 0))
while not q.empty():
v, l = q.get()
for i in vector[v]:
new_l = (l+1)%3
if dist[i][new_l] != INF:
continue
dist[i][new_l] = dist[v][l] + 1
q.put((i, new_l))
ans = dist[T][0]
if ans == INF:
print("-1")
else:
print((int(ans/3))) | p02991 |
from queue import Queue
N, M = list(map(int, input().split()))
INF = -1
dist = [[INF]*3 for _ in range(N)]
vector = [[] for _ in range(N)]
for i in range(M):
graf1, graf2 = list(map(int, input().split()))
vector[graf1-1].append(graf2-1)
S, T = list(map(int, input().split()))
S, T = S-1, T-1
# BFS
dist[S][0] = 0
q = Queue(3*N+1)
q.put((S, 0))
while not q.empty():
v, l = q.get()
for i in vector[v]:
new_l = (l+1)%3
if dist[i][new_l] != INF:
continue
dist[i][new_l] = dist[v][l] + 1
q.put((i, new_l))
ans = dist[T][0]
if ans == INF:
print("-1")
else:
print((int(ans/3))) | from collections import deque
N, M = list(map(int, input().split()))
INF = -1
dist = [[INF]*3 for _ in range(N)]
vector = [[] for _ in range(N)]
for i in range(M):
graf1, graf2 = list(map(int, input().split()))
vector[graf1-1].append(graf2-1)
S, T = list(map(int, input().split()))
S, T = S-1, T-1
# BFS
dist[S][0] = 0
q = deque()
q.append((S, 0))
while q:
v, l = q.popleft()
for i in vector[v]:
new_l = (l+1)%3
if dist[i][new_l] != INF:
continue
dist[i][new_l] = dist[v][l] + 1
q.append((i, new_l))
ans = dist[T][0]
if ans == INF:
print("-1")
else:
print((int(ans/3))) | p02991 |
from collections import deque
N,M,*L,S,T = list(map(int,open(0).read().split()))
G = [[] for _ in range(N)]
step = [[-1]*3 for _ in range(N)]
step[S-1][0] = 0
for u,v in zip(*[iter(L)]*2):
G[u-1].append(v-1)
q = deque([(S-1,0)])
while q:
cur,d = q.popleft()
for nxt in G[cur]:
if nxt==T-1 and (d+1)%3==0:
print(((d+1)//3))
exit()
if step[nxt][(d+1)%3] < 0:
step[nxt][(d+1)%3] = d+1
q.append((nxt,d+1))
print((-1)) | from collections import deque
N,M,*L,S,T = list(map(int,open(0).read().split()))
G = [[] for _ in range(N)]
step = [False for _ in range(3*N)]
step[(S-1)*3] = 0
for u,v in zip(*[iter(L)]*2):
G[u-1].append(v-1)
q = deque([(S-1,0)])
while q:
cur,d = q.popleft()
for nxt in G[cur]:
if nxt==T-1 and (d+1)%3==0:
print(((d+1)//3))
exit()
if not step[nxt*3+(d+1)%3]:
step[nxt*3+(d+1)%3] = True
q.append((nxt,d+1))
print((-1)) | p02991 |
from collections import deque
N,M,*L,S,T = list(map(int,open(0).read().split()))
G = [[] for _ in range(N)]
step = [0 for _ in range(N)]
step[S-1] = 1
for u,v in zip(*[iter(L)]*2):
G[u-1].append(v-1)
q = deque([(S-1,0)])
while q:
cur,d = q.popleft()
for nxt in G[cur]:
if nxt==T-1 and (d+1)%3==0:
print(((d+1)//3))
exit()
if not step[nxt] & 1<<((d+1)%3):
step[nxt] |= 1<<(d+1)%3
q.append((nxt,d+1))
print((-1)) | def main():
from collections import deque
N,M,*L,S,T = list(map(int,open(0).read().split()))
G = [[] for _ in range(N)]
step = [False]*(3*N)
step[(S-1)*3] = True
for u,v in zip(*[iter(L)]*2):
G[u-1].append(v-1)
q = deque([(S-1,0)])
while q:
cur,d = q.popleft()
for nxt in G[cur]:
if nxt==T-1 and (d+1)%3==0:
print(((d+1)//3))
exit()
if not step[nxt*3+(d+1)%3]:
step[nxt*3+(d+1)%3] = True
q.append((nxt,d+1))
print((-1))
if __name__=="__main__":main() | p02991 |
from collections import deque
n,m = list(map(int,input().split()))
es = [[] for _ in range(n+1)]
for _ in range(m):
u,v = list(map(int,input().split()))
es[u].append(v)
to = [[] for _ in range(n+1)]
for i in range(1, n+1):
que = deque([])
for j in es[i]:
que.append((j, 1))
while que:
v,c = que.popleft()
if c > 3:
continue
elif c==3:
if v not in to[i]:
to[i].append(v)
else:
for j in es[v]:
que.append((j, c+1))
s,t = list(map(int,input().split()))
visited = [False]*(n+1)
que = deque([])
for st in to[s]:
que.append((st, 1))
ans = -1
while que:
v,c = que.popleft()
if visited[v]:
continue
elif v==t:
ans = c
break
else:
visited[v] = True
for nx in to[v]:
que.append((nx,c+1))
print(ans) | n,m = list(map(int,input().split()))
if m==0:
print((-1))
exit()
es = [[] for _ in range(n+1)]
for _ in range(m):
u,v = list(map(int,input().split()))
es[u].append(v)
s,t = list(map(int,input().split()))
INF = 10**9
dist = [[INF,INF,INF] for _ in range(n+1)]
d = 0
q = [s]
while q:
d += 1
r = d%3
qq = []
for u in q:
for v in es[u]:
if dist[v][r] == INF:
dist[v][r] = d
qq.append(v)
q = qq
d = dist[t][0]
print((-1 if d==INF else d//3)) | p02991 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
# N-1辺表示をグラフ表示に
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a-1].append(b-1)
S, T = [int(x)-1 for x in input().split()]
q = [S]
checked = [False]*N
checked[S] = True
ok = False
c = 0
while q:
c += 1
qq = []
if c % 3 == 0:
for p in q:
for np in graph[p]:
if np == T:
ok = True
break
if not checked[np]:
qq.append(np)
checked[np] = True
else:
for p in q:
for np in graph[p]:
qq.append(np)
if ok:
break
q = qq
if ok:
print((c//3))
else:
print((-1)) | import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
# N-1辺表示をグラフ表示に
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a-1].append(b-1)
S, T = [int(x)-1 for x in input().split()]
q = {S}
checked = [False]*N
checked[S] = True
ok = False
c = 0
while q:
c += 1
qq = set()
if c % 3 == 0:
for p in q:
for np in graph[p]:
if np == T:
ok = True
break
if not checked[np]:
qq.add(np)
checked[np] = True
else:
for p in q:
for np in graph[p]:
qq.add(np)
if ok:
break
q = qq
if ok:
print((c//3))
else:
print((-1)) | p02991 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
# N-1辺表示をグラフ表示に
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a-1].append(b-1)
S, T = [int(x)-1 for x in input().split()]
q = {S}
checked = [False]*N
checked[S] = True
ok = False
c = 0
while q:
c += 1
qq = set()
if c % 3 == 0:
for p in q:
for np in graph[p]:
if np == T:
ok = True
break
if not checked[np]:
qq.add(np)
checked[np] = True
else:
for p in q:
for np in graph[p]:
qq.add(np)
if ok:
break
q = qq
if ok:
print((c//3))
else:
print((-1)) | import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a-1].append(b-1)
#graph[b-1].append(a-1)
S, T = list(map(int, input().split()))
S -= 1; T -= 1
D = [[-1]*3 for _ in range(N)]
D[S][0] = 0
q = [(S, 0)]
while q:
qq = []
for p, d in q:
for np in graph[p]:
nd = (d+1)%3
if D[np][nd] == -1:
D[np][nd] = D[p][d] + 1
qq.append((np, nd))
q = qq
if D[T][0] == -1:
print((-1))
else:
print((D[T][0]//3)) | p02991 |
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
from collections import defaultdict
dic = defaultdict(list)
for _ in range(m):
u,v = list(map(int,input().split()))
dic[u-1].append(v-1)
G = defaultdict(list)
def dfs(p, s, l):
if l == 3:
if s != p:
G[s].append(p)
else:
for i in dic[p]:
dfs(i, s, l+1)
for i in range(n):
dfs(i, i, 0)
s,t = list(map(int,input().split()))
# G[v]: 頂点vに隣接する頂点list
# N: 頂点数
from collections import deque
dist = [-1]*n
que = deque([s-1])
dist[s-1] = 0
while que:
v = que.popleft()
d = dist[v]
for w in G[v]:
if dist[w] > -1:
continue
dist[w] = d + 1
que.append(w)
print((dist[t-1])) | import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
from collections import defaultdict
dic = defaultdict(list)
for _ in range(m):
u,v = list(map(int,input().split()))
dic[u-1].append(v-1+n)
dic[u - 1+n].append(v - 1 + 2*n)
dic[u - 1+2*n].append(v - 1)
G = dic
s,t = list(map(int,input().split()))
# G[v]: 頂点vに隣接する頂点list
# N: 頂点数
from collections import deque
dist = [-1]*(n*3)
que = deque([s-1])
dist[s-1] = 0
while que:
v = que.popleft()
d = dist[v]
for w in G[v]:
if dist[w] > -1:
continue
dist[w] = d + 1
que.append(w)
print((dist[t-1]//3))
| p02991 |
from collections import defaultdict, deque
def bfs(V, s, t):
q = deque([(0, s)])
used = set()
while q:
dist, a = q.popleft()
used.add(a)
if a == t:
break
for b in V[a]:
if b in used: continue
q.append((dist+1, b))
if a != t:
dist = -1
else:
dist = -1 if dist%3 else dist//3
return dist
if __name__ == "__main__":
V = defaultdict(list)
N, M = list(map(int, input().split()))
for _ in range(M):
u, v = list(map(int, input().split()))
V[u].append(v*(N+1))
V[u*(N+1)].append(v*(2*N+1))
V[u*(2*N+1)].append(v)
S, T = list(map(int, input().split()))
dist = bfs(V, S, T)
print(dist)
| from collections import defaultdict, deque
from heapq import heappush, heappop
def bfs(V, s, t):
q = deque([(0, s)])
used = set()
while q:
dist, a = q.popleft()
used.add(a)
if a == t:
break
for b in V[a]:
if b in used: continue
q.append((dist+1, b))
if a != t:
dist = -1
else:
dist = -1 if dist%3 else dist//3
return dist
def dijkstra1(V, n, source):
# O(ElogV)
inf = float("inf")
dist = [inf] * (n+1)
dist[source] = 0
q = [(0, source)]
while q:
cost, u = heappop(q)
if dist[u] < cost:
continue
for c, v in V[u]:
if dist[v] > dist[u] + c:
dist[v] = dist[u] + c
heappush(q, (dist[v], v))
return dist
if __name__ == "__main__":
V = defaultdict(list)
N, M = list(map(int, input().split()))
for _ in range(M):
u, v = list(map(int, input().split()))
V[u].append((1, v+(N)))
V[u+(N)].append((1, v+(2*N)))
V[u+(2*N)].append((1, v))
S, T = list(map(int, input().split()))
dist = dijkstra1(V, 3*N, S)[T]
print((-1 if dist==float("inf") else dist//3)) | p02991 |
from collections import defaultdict, deque
from heapq import heappush, heappop
def bfs(V, s, t):
q = deque([(0, s)])
used = set()
while q:
dist, a = q.popleft()
used.add(a)
if a == t:
break
for b in V[a]:
if b in used: continue
q.append((dist+1, b))
if a != t:
dist = -1
else:
dist = -1 if dist%3 else dist//3
return dist
def dijkstra1(V, n, source):
# O(ElogV)
inf = float("inf")
dist = [inf] * (n+1)
dist[source] = 0
q = [(0, source)]
while q:
cost, u = heappop(q)
if dist[u] < cost:
continue
for c, v in V[u]:
if dist[v] > dist[u] + c:
dist[v] = dist[u] + c
heappush(q, (dist[v], v))
return dist
if __name__ == "__main__":
V = defaultdict(list)
N, M = list(map(int, input().split()))
for _ in range(M):
u, v = list(map(int, input().split()))
V[u].append((1, v+(N)))
V[u+(N)].append((1, v+(2*N)))
V[u+(2*N)].append((1, v))
S, T = list(map(int, input().split()))
dist = dijkstra1(V, 3*N, S)[T]
print((-1 if dist==float("inf") else dist//3)) | from heapq import heappush, heappop
def dijkstra1(V, n, source):
# O(ElogV)
inf = float("inf")
dist = [inf] * (n+1)
dist[source] = 0
q = [(0, source)]
while q:
cost, u = heappop(q)
if dist[u] < cost:
continue
for c, v in V[u]:
if dist[v] > dist[u] + c:
dist[v] = dist[u] + c
heappush(q, (dist[v], v))
return dist
if __name__ == "__main__":
N, M = list(map(int, input().split()))
V = {i:[] for i in range(1, 3*N+1)}
for _ in range(M):
u, v = list(map(int, input().split()))
V[u].append((1, v+(N)))
V[u+(N)].append((1, v+(2*N)))
V[u+(2*N)].append((1, v))
S, T = list(map(int, input().split()))
dist = dijkstra1(V, 3*N, S)[T]
print((-1 if dist==float("inf") else dist//3)) | p02991 |
from heapq import heappush, heappop
def dijkstra1(V, n, source):
# O(ElogV)
inf = float("inf")
dist = [inf] * (n+1)
dist[source] = 0
q = [(0, source)]
while q:
cost, u = heappop(q)
if dist[u] < cost:
continue
for c, v in V[u]:
if dist[v] > dist[u] + c:
dist[v] = dist[u] + c
heappush(q, (dist[v], v))
return dist
def solve():
N, M = list(map(int, input().split()))
V = {i:[] for i in range(1, 3*N+1)}
for _ in range(M):
u, v = list(map(int, input().split()))
V[u].append((1, v+(N)))
V[u+(N)].append((1, v+(2*N)))
V[u+(2*N)].append((1, v))
S, T = list(map(int, input().split()))
dist = dijkstra1(V, 3*N, S)[T]
print((-1 if dist==float("inf") else dist//3))
if __name__ == "__main__":
solve() | from heapq import heappush, heappop
def dijkstra1(V, n, inf, source):
# O(ElogV)
dist = [inf] * (n+1)
dist[source] = 0
q = [(0, source)]
while q:
cost, u = heappop(q)
if dist[u] < cost:
continue
for c, v in V[u]:
if dist[v] > dist[u] + c:
dist[v] = dist[u] + c
heappush(q, (dist[v], v))
return dist
def solve():
INF = 10**25
N, M = list(map(int, input().split()))
V = {i:[] for i in range(1, 3*N+1)}
for _ in range(M):
u, v = list(map(int, input().split()))
V[u].append((1, v+(N)))
V[u+(N)].append((1, v+(2*N)))
V[u+(2*N)].append((1, v))
S, T = list(map(int, input().split()))
dist = dijkstra1(V, 3*N, INF, S)[T]
print((-1 if dist==INF else dist//3))
if __name__ == "__main__":
solve() | p02991 |
from collections import deque
n, m = list(map(int, input().split()))
inf = 10**9
def bfs(start):
dist = [inf for i in range((n+1) * 3)]
que = deque()
que.append(start)
finished = set()
dist[start] = 0
while que:
node = que.popleft()
if node not in finished:
finished.add(node)
for i in adjacent_list[node]:
dist[i] = min(dist[i], dist[node] + 1)
que.append(i)
return dist
adjacent_list = [[] for i in range((n+1)*3)]
for _ in range(m):
u, v = list(map(int, input().split()))
for i in range(3):
adjacent_list[u*3 + i].append(v*3 +((i+1)%3))
start, goal = list(map(int, input().split()))
graph = bfs(start*3)
if graph[goal*3] != inf:
print((int(graph[goal*3]) // 3))
else:
print((-1)) | from collections import deque
n, m = list(map(int, input().split()))
adjacent_list = [[] for i in range(3*n + 3)]
for i in range(m):
u, v = list(map(int, input().split()))
for j in range(1,4):
p = j + 3 * u - 3
q = (j % 3) + 3 * v - 2
#print("{} -> {}".format(p, q))
adjacent_list[p].append(q)
s, t = list(map(int, input().split()))
def bfs(start, target):
que = deque()
finished = set()
que.append([start, 0])
while que:
node, dist = que.popleft()
if (node, dist % 3) in finished:
continue
if node == target:
return dist // 3
for i in adjacent_list[node]:
que.append([i, dist+1])
finished.add((node, dist % 3))
return -1
print((bfs(s*3 -2, 3*t-2)))
| p02991 |
n,m=list(map(int,input().split()))
g=[[] for _ in range(n)]
for _ in range(m):
a,b=list(map(int,input().split()))
a,b=a-1,b-1
g[a].append(b)
s,t=list(map(int,input().split()))
s,t=s-1,t-1
gg=[set(()) for _ in range(n)]
for i in range(n):
for j in g[i]:
for k in g[j]:
for l in g[k]:
if l!=i:
gg[i].add(l)
from collections import deque
todo=deque([s])
seen=[-1]*n
seen[s]=0
while todo:
v=todo.popleft()
for l in gg[v]:
if seen[l]==-1:
todo.append(l)
seen[l]=seen[v]+1
print((seen[t])) | n,m=list(map(int,input().split()))
g=[[] for _ in range(n)]
gg=[[] for _ in range(3*n)]
for _ in range(m):
a,b=list(map(int,input().split()))
a,b=a-1,b-1
gg[a].append(n+b)
gg[n+a].append(2*n+b)
gg[2*n+a].append(b)
s,t=list(map(int,input().split()))
s,t=s-1,t-1
from collections import deque
todo=deque([s])
seen=[-1]*(3*n)
seen[s]=0
while todo:
v=todo.popleft()
for l in gg[v]:
if seen[l]==-1:
todo.append(l)
seen[l]=seen[v]+1
if l==t:
print((seen[l]//3))
exit()
if seen[t]>0:
print((seen[t]//3))
else:
print((-1)) | p02991 |
import sys
from collections import deque
data = sys.stdin.readlines()
N, M = list(map(int, data[0].split()))
edge = [[] for _ in range(N)]
for i in range(1, M + 1):
u, v = list(map(int, data[i].split()))
u -= 1
v -= 1
edge[u].append(v)
S, T = [int(x) - 1 for x in data[M + 1].split()]
def bfs1(s):
q = deque()
q.append((s, 0))
while len(q) > 0:
v, step = q.popleft()
if step == 3:
edge3[s].append(v)
else:
for nv in edge[v]:
q.append((nv, step + 1))
def bfs2(n):
global T
q = deque()
status[n] = 0
q.append(n)
while len(q) > 0:
v = q.popleft()
for nv in edge3[v]:
if status[nv] == -1:
status[nv] = status[v] + 1
q.append(nv)
edge3 = [[] for _ in range(N)]
for i in range(N):
bfs1(i)
status = [-1] * N
status[S] = 0
bfs2(S)
print((status[T]))
| import sys
from collections import deque
data = sys.stdin.readlines()
N, M = list(map(int, data[0].split()))
edge = [[] for _ in range(N)]
for i in range(1, M + 1):
u, v = list(map(int, data[i].split()))
u -= 1
v -= 1
edge[u].append(v)
S, T = [int(x) - 1 for x in data[M + 1].split()]
visited = set()
q = deque()
q.append((0, S))
ans = 10 ** 10
while len(q) > 0:
c, v = q.popleft()
key = (c % 3, v)
if key in visited:
continue
visited.add(key)
if v == T and c % 3 == 0:
ans = min(ans, c // 3)
else:
for e in edge[v]:
newKey = (c + 1, e)
q.append(newKey)
if ans == 10 ** 10:
print((-1))
else:
print(ans)
| p02991 |
from collections import*
n,m,*w,s,t=list(map(int,open(0).read().split()))
e=[[]for _ in range(n+1)]
for u,v in zip(w[::2],w[1::2]):e[u].append(v)
f=[[-3]*3for _ in range(n+1)]
f[s][0]=0
q=deque([(s,0)])
while q:
v,m=q.popleft()
for w in e[v]:
if f[w][-~m%3]<0:
f[w][-~m%3]=f[v][m]+1
q+=[(w,-~m%3)]
print((f[t][0]//3)) | from collections import*
n,m,*w,s,t=list(map(int,open(0).read().split()))
e=[[]for _ in[0]*-~n]
for u,v in zip(w[::2],w[1::2]):e[u]+=v,
f=[-3]*n*4
f[s*3]=0
q=deque([(s,0)])
while q:
v,m=q.popleft()
u=-~m%3
for w in e[v]:
if f[w*3+u]<0:
f[w*3+u]=f[v*3+m]+1
q+=(w,u),
print((f[t*3]//3)) | p02991 |
from collections import deque
n, m = list(map(int, input().split()))
uv =[[] for _ in range(n)]
for _ in range(m):
u, v = list(map(int, input().split()))
uv[u - 1].append(v - 1)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
uv2 = [[] for _ in range(n)]
uv3 = [[] for _ in range(n)]
for i, lst in enumerate(uv):
for j in lst:
lst2 = uv[j]
for k in lst2:
uv2[i].append(k)
for i, lst in enumerate(uv):
for j in lst:
lst2 = uv2[j]
for k in lst2:
uv3[i].append(k)
queue = deque()
queue.append(s)
queue.append(1)
check = [False for _ in range(n)]
check[s] = True
while queue:
pos = queue.popleft()
ans = queue.popleft()
for next_pos in uv3[pos]:
if next_pos == t:
print(ans)
exit()
if check[next_pos]:
continue
check[next_pos] = True
queue.append(next_pos)
queue.append(ans + 1)
print((-1))
| from collections import deque
n, m = list(map(int, input().split()))
uv =[[] for _ in range(n)]
for _ in range(m):
u, v = list(map(int, input().split()))
uv[u - 1].append(v - 1)
s, t = list(map(int, input().split()))
s -= 1
t -= 1
queue = deque()
queue.append(s)
queue.append(1)
queue.append(0)
check = [[False for _ in range(3)] for _ in range(n)]
check[s][0] = True
while queue:
pos = queue.popleft()
ans = queue.popleft()
kkp = queue.popleft()
for next_pos in uv[pos]:
if next_pos == t and kkp == 2:
print((ans // 3))
exit()
if check[next_pos][(kkp + 1) % 3]:
continue
check[next_pos][(kkp + 1) % 3] = True
queue.append(next_pos)
queue.append(ans + 1)
queue.append((kkp + 1) % 3)
print((-1))
| p02991 |
N, M = list(map(int,input().split()))
L1 = [set() for k in range(3*(N+1))]
for k in range(M):
u, v = list(map(int, input().split()))
L1[3*u].add(3*v+1)
L1[3*u+1].add(3*v+2)
L1[3*u+2].add(3*v)
S, T = list(map(int, input().split()))
S = 3*S
T = set([3*T])
t = 0
sumi = set([S])
now = set([S])
flg = 0
while(len(now) != 0):
t += 1
pre = set()
for n in now:
pre = pre.union(L1[n])
now = pre - sumi
sumi = sumi.union(pre)
if T <= pre:
print((t//3))
flg =1
break
if flg == 0:
print((-1)) | N, M = list(map(int,input().split()))
L1 = [[] for k in range(3*(N+1))]
for k in range(M):
u, v = list(map(int, input().split()))
L1[3*u].append(3*v+1)
L1[3*u+1].append(3*v+2)
L1[3*u+2].append(3*v)
S, T = list(map(int, input().split()))
S = 3*S
T = 3*T
t = 0
sumi = [None for k in range(3*(N+1))]
sumi[T] = -1
now = [S]
flg = 0
while(len(now) != 0):
t += 1
pre = []
for n in now:
pre.extend(L1[n])
now = []
for p in pre:
if sumi[p] == None:
sumi[p] = t
now.append(p)
elif sumi[p] == -1:
flg = 1
if flg == 1:
print((t//3))
flg = 2
break
if flg == 0:
print((-1)) | p02991 |
import sys
from collections import deque
sys.setrecursionlimit(10000000)
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
uv = [list(map(int, readline().split())) for i in range(M)]
S, T = list(map(int, readline().split()))
S, T = S - 1, T - 1
nodes = [{} for i in range(N)]
for u, v in uv:
nodes[u - 1][v - 1] = 1
visited = [False] * N
def kenken(u, rem):
if rem > 0:
a = []
for v in nodes[u]:
a += kenken(v, rem - 1)
return a
else:
return [u]
q = deque()
q.append([S, 0])
_count = -1
while len(q) != 0:
u, count = q.popleft()
if not visited[u]:
visited[u] = True
ret = kenken(u, 3)
if any(T == r for r in ret):
_count = count + 1
break
q.extend([r, count + 1] for r in ret)
print(_count) | import sys
from collections import deque
sys.setrecursionlimit(10000000)
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
uv = [list(map(int, readline().split())) for i in range(M)]
S, T = list(map(int, readline().split()))
S, T = S - 1, T - 1
nodes = [{} for i in range(N)]
for u, v in uv:
nodes[u - 1][v - 1] = 1
visited = [[False] * N for i in range(3)]
def kenken(u, rem):
if rem != 3 and visited[rem][u]:
return deque()
if rem != 3:
visited[rem][u] = True
if rem > 0:
a = deque()
for v in nodes[u]:
a.extend(kenken(v, rem - 1))
return a
else:
return deque([u])
q = deque()
q.append([S, 0])
_count = -1
while len(q) != 0:
u, count = q.popleft()
ret = kenken(u, 3)
if any(T == r for r in ret):
_count = count + 1
break
q.extend([r, count + 1] for r in ret)
print(_count) | p02991 |
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_,input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
N, M = MI()
edge = [[] for _ in range(N)]
for _ in range(M):
u,v = MI_()
edge[u].append(v)
S, T = MI_()
edge2 = [[] for _ in range(N)]
for sor in range(N):
queue = [sor]
for _ in range(3):
tmp = set()
while queue:
now = queue.pop()
for to in edge[now]:
tmp.add(to)
queue = tmp
edge2[sor] = queue
#print(*edge2,sep="\n")
queue = [S]
checked = set()
for i in range(1,max(N,M+2)):
tmp = set()
while queue:
s = queue.pop()
for to in edge2[s]:
if to == T:
print(i)
exit()
else:
if to not in checked:
tmp.add(to)
checked.add(to)
queue = tmp
print((-1))
if __name__ == '__main__':
main() | #
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_,input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
N, M = MI()
edge = [[] for _ in range(N)]
for _ in range(M):
u,v = MI_()
edge[u].append(v)
S, T = MI_()
queue = [S]
checked = set()
for i in range(1,max(3*N,3*M+2)):
tmp = set()
while queue:
s = queue.pop()
for to in edge[s]:
if to == T:
if i%3==0:
print((i//3))
exit()
tmp.add(to)
queue = tmp
print((-1))
if __name__ == '__main__':
main() | p02991 |
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_,input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
N, M = MI()
edge = [[] for _ in range(N)]
for _ in range(M):
u,v = MI_()
edge[u].append(v)
S, T = MI_()
queue = [S]
checked = set()
for i in range(1,max(3*N,3*M+2)):
tmp = set()
while queue:
s = queue.pop()
for to in edge[s]:
if to == T:
if i%3==0:
print((i//3))
exit()
tmp.add(to)
queue = tmp
print((-1))
if __name__ == '__main__':
main() | #
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_,input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
N, M = MI()
edge = [[] for _ in range(N)]
for _ in range(M):
u,v = MI_()
edge[u].append(v)
S, T = MI_()
queue = [S]
checked = set()
for i in range(1,max(3*N+1,3*M+2)):
tmp = set()
while queue:
s = queue.pop()
if i % 3 == 0:
if s in checked:
continue
else:
checked.add(s)
for to in edge[s]:
if to == T:
if i%3==0:
print((i//3))
exit()
tmp.add(to)
queue = tmp
print((-1))
if __name__ == '__main__':
main() | p02991 |
N, M = list(map(int, input().split()))
a = [[] for i in range(N+1)]
for i in range(M):
u, v = list(map(int, input().split()))
a[u].append(v)
#print(a)
S, T = list(map(int, input().split()))
def main():
c = [S]
m = [[False, False, False] for i in range(N+1)]
for count in range(1, 3*N+1):
vs = []
for u in c:
m[u][count %3] = True
vs += a[u]
c = []
for v in vs:
if (v == T and count %3 ==0):
return count//3
if not(m[v][(count+1) %3]):
c.append(v)
return -1
print((main()))
| N, M = list(map(int, input().split()))
a = [[] for i in range(N+1)]
for i in range(M):
u, v = list(map(int, input().split()))
a[u].append(v)
#print(a)
S, T = list(map(int, input().split()))
def main():
c = [S]
m = [[False, False, False] for i in range(N+1)]
for count in range(1, 3*N+1):
c2 = []
for u in c:
m[u][count %3] = True
for v in a[u]:
if (v == T and count %3 ==0):
return count//3
if not(m[v][(count+1) %3]):
c2.append(v)
c = c2
return -1
print((main()))
| p02991 |
import sys
from collections import deque
input = sys.stdin.readline
n, m = list(map(int, input().split()))
info = tuple(list(map(int, input().split())) for i in range(m))
s, t = list(map(int, input().split()))
graph = [[] for i in range(n)]
for i, j in info:
graph[i-1].append(j-1)
graph2 = [[] for i in range(n)]
q = deque()
q.append((s - 1, 0))
INF = float("inf")
visited = [INF] * n
visited[0] = 0
while q:
pos, times = q.popleft()
for i in graph[pos]:
if (times + 1) % 3 != 0:
q.append((i, times + 1))
if (times + 1) % 3 == 0 and times + 1 < visited[i]:
visited[i] = times + 1
q.append((i, times+1))
if visited[t-1] == float("inf"):
print((-1))
else:
print((visited[t-1]//3))
| import sys
from collections import deque
input = sys.stdin.readline
n, m = list(map(int, input().split()))
info = tuple(list(map(int, input().split())) for i in range(m))
s, t = list(map(int, input().split()))
graph = [[] for i in range(n)]
for i, j in info:
graph[i-1].append(j-1)
q = deque()
q.append((s - 1, 0))
INF = 10 ** 10
visited = [10 ** 10] * n
visited_1 = [10 ** 10] * n
visited_2 = [10 ** 10] * n
visited[s - 1] = 0
while q:
pos, times = q.popleft()
for i in graph[pos]:
if (times + 1) % 3 == 1 and times + 1 < visited_1[i]:
visited_1[i] = times + 1
q.append((i, times + 1))
elif (times + 1) % 3 == 2 and times + 1 < visited_2[i]:
visited_2[i] = times + 1
q.append((i, times + 1))
elif (times + 1) % 3 == 0 and times + 1 < visited[i]:
visited[i] = times + 1
q.append((i, times + 1))
if visited[t - 1] == 10 ** 10:
print((-1))
else:
print((visited[t-1]//3))
| p02991 |
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(eval(input()))
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
class Dijkstra():
def __init__(self):
self.e = collections.defaultdict(list)
def add(self, u, v, d, directed=False):
"""
Parameters
----------
u:int
from node
v:int
to node
d:int
cost
directed:bool
there is direction
"""
if directed is False:
self.e[u].append([v, d])
self.e[v].append([u, d])
else:
self.e[u].append([v, d])
def delete(self, u, v):
"""
Parameters
----------
u:int
from node
v:int
to node
"""
self.e[u] = [_ for _ in self.e[u] if _[0] != v]
self.e[v] = [_ for _ in self.e[v] if _[0] != u]
def Dijkstra_search(self, s):
"""
Parameters
----------
s:int
start node
Return
----------
d:dict(int:int)
shortest cost from start node to each node
{to : cost}
prev:dict(int:int)
previous node on the shortest path
{from : to}
"""
d = collections.defaultdict(lambda: float('inf'))
prev = collections.defaultdict(lambda: None)
d[s] = 0
q = []
heapq.heappush(q, (0, s)) # (cost, 探索候補ノード)
v = collections.defaultdict(bool) # 確定済かどうか
while len(q):
# ノードuにおけるコストはk
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
for uv, ud in self.e[u]: # cost is ud from u to uv
if v[uv]:
continue
vd = k + ud
if d[uv] > vd:
d[uv] = vd
prev[uv] = u
heapq.heappush(q, (vd, uv))
return d, prev
n, m = inpl()
graph=collections.defaultdict(set)
for i in range(m):
u, v = inpl()
graph[u].add(v)
s,t=inpl()
@lru_cache(maxsize=None)
def dfs(node, k):
k-=1
if k == 0:
return graph[node]
tmp=set()
for i in graph[node]:
tmp |= dfs(i, k)
return tmp
ans = 0
new_graph = Dijkstra()
for i in range(1,n+1):
for j in dfs(i, 3):
new_graph.add(i, j, 1, directed=True)
d, _ = new_graph.Dijkstra_search(s)
ans=d[t] if d[t]!=INF else -1
print(ans) | import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(eval(input()))
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
class Dijkstra():
def __init__(self):
self.e = collections.defaultdict(list)
def add(self, u, v, d, directed=False):
"""
Parameters
----------
u:int
from node
v:int
to node
d:int
cost
directed:bool
there is direction
"""
if directed is False:
self.e[u].append([v, d])
self.e[v].append([u, d])
else:
self.e[u].append([v, d])
def delete(self, u, v):
"""
Parameters
----------
u:int
from node
v:int
to node
"""
self.e[u] = [_ for _ in self.e[u] if _[0] != v]
self.e[v] = [_ for _ in self.e[v] if _[0] != u]
def Dijkstra_search(self, s):
"""
Parameters
----------
s:int
start node
Return
----------
d:dict(int:int)
shortest cost from start node to each node
{to : cost}
prev:dict(int:int)
previous node on the shortest path
{from : to}
"""
d = collections.defaultdict(lambda: float('inf'))
prev = collections.defaultdict(lambda: None)
d[s] = 0
q = []
heapq.heappush(q, (0, s)) # (cost, 探索候補ノード)
v = collections.defaultdict(bool) # 確定済かどうか
while len(q):
# ノードuにおけるコストはk
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
for uv, ud in self.e[u]: # cost is ud from u to uv
if v[uv]:
continue
vd = k + ud
if d[uv] > vd:
d[uv] = vd
prev[uv] = u
heapq.heappush(q, (vd, uv))
return d, prev
n, m = inpl()
graph=Dijkstra()
for i in range(m):
u, v = inpl()
graph.add(u,v+n,1,directed=True)
graph.add(u+n,v+n+n,1,directed=True)
graph.add(u+n+n,v,1,directed=True)
s,t=inpl()
ans = 0
d, _ = graph.Dijkstra_search(s)
ans = d[t] if d[t] != INF else - 1
# print(d)
print((ans//3)) | p02991 |
# 最大でも3Nしか頂点には回らない
import sys
from collections import deque
input = sys.stdin.readline
n, m = list(map(int, input().split()))
edges = [[] for i in range(n)]
for i in range(m):
u,v = list(map(int, input().split()))
u -= 1
v -= 1
edges[u].append(v)
dist = [[False]*3 for i in range(n)]
cnt = [[0]*3 for i in range(n)]
s, t = list(map(int, input().split()))
s -= 1
t -= 1
q = deque()
# now, dist(mod3), cnt
q.append((s, 0, 0))
while q:
now, d, c = q.popleft()
if dist[now][d] and cnt[now][d] < c:
continue
dist[now][d] = True
cnt[now][d] = c
next_d = (d+1)%3
next_c = c+1
for to in edges[now]:
if not dist[to][next_d] or cnt[to][next_d] > c:
q.appendleft((to, next_d,next_c))
if dist[t][0]:
print((cnt[t][0]//3))
else:
print((-1)) | # 最大でも3Nしか頂点には回らない
import sys
from collections import deque
input = sys.stdin.readline
n, m = list(map(int, input().split()))
edges = [[] for i in range(n)]
for i in range(m):
u,v = list(map(int, input().split()))
u -= 1
v -= 1
edges[u].append(v)
dist = [[False]*3 for i in range(n)]
cnt = [[0]*3 for i in range(n)]
s, t = list(map(int, input().split()))
s -= 1
t -= 1
q = deque()
# now, dist(mod3), cnt
q.append((s, 0, 0))
while q:
now, d, c = q.popleft()
if dist[now][d] and cnt[now][d] <= c:
continue
dist[now][d] = True
cnt[now][d] = c
next_d = (d+1)%3
next_c = c+1
for to in edges[now]:
if not dist[to][next_d] or cnt[to][next_d] > c:
q.append((to, next_d,next_c))
if dist[t][0]:
print((cnt[t][0]//3))
else:
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()))
l = [[] for u in range(n + 1)]
for u, v in uv:
l[u].append(v)
def bfs(v):
q = [(x, 0) for x in list(v)]
visited = set(q)
while len(q) > 0:
x, step = q.pop(0)
if step == 3:
v.add(x)
continue
for y in l[x]:
next = (y, step + 1)
if next not in visited:
visited.add(next)
q.append(next)
return v
v = set([s])
ret = 0
while True:
olen = len(v)
v = bfs(v)
ret += 1
if t in v:
break
if len(v) == olen:
ret = -1
break
print(ret) | n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
l = [[] for u in range(n + 1)]
for u, v in uv:
l[u].append(v)
def bfs(v):
q = [(x, 0) for x in list(v)]
index = 0
ret = set()
while len(q) > index:
x, step = q[index]
index += 1
if step == 3:
ret.add(x)
continue
for y in l[x]:
next = (y, step + 1)
if next not in visited:
visited.add(next)
q.append(next)
return ret
v = set([s])
visited = set([(s, 0)])
ret = 0
while True:
v2 = bfs(v)
if len(v2) == 0:
ret = -1
break
ret += 1
if t in v2:
break
v = v2
print(ret) | p02991 |
n,m=list(map(int,input().split()))
path=[[] for i in range(n+1)]
for i in range(m):
u,v=list(map(int,input().split()))
path[u].append(v)
S,T=list(map(int,input().split()))
que=[S]
flag=[0]*(n+1)
flag[S]=1
data=[[] for i in range(n+1)]
while que:
h=que.pop()
lst=[h]
for i in range(3):
u=[]
for j in lst:
for k in path[j]:
u.append(k)
lst=u
lst=list(set(lst))
for i in lst:
if i==h:
continue
data[h].append(i)
if flag[i]==0:
flag[i]=1
que.append(i)
que=[S]
flag=[0]*(n+1)
flag[S]=1
count=0
while que:
count+=1
H=[]
for u in que:
for v in data[u]:
if flag[v]==0:
H.append(v)
flag[v]=1
if v==T:
print(count)
break
else:
continue
break
else:
que=H
continue
break
else:
print((-1)) | n,m=list(map(int,input().split()))
data=[[] for i in range(3*n+1)]
for i in range(m):
u,v=list(map(int,input().split()))
data[u].append(v+n)
data[u+n].append(v+2*n)
data[u+2*n].append(v)
s,t=list(map(int,input().split()))
inf=float("inf")
flag=[inf]*(3*n+1)
flag[s]=0
que=[s]
while que:
h=[]
for u in que:
for v in data[u]:
if flag[v]==inf:
flag[v]=flag[u]+1
h.append(v)
que=h
if flag[t]==inf:
print((-1))
else:
print((flag[t]//3)) | p02991 |
import sys
from collections import defaultdict
input=sys.stdin.readline
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()))
D=defaultdict(int)
L=[s]
LL,LLL,LLLL,l=[],[],[],[]
cnt=0
while L:
if t in L:
print(cnt)
exit()
for i in L:
for j in G[i]:
LL.append(j)
for ii in LL:
for jj in G[ii]:
LLL.append(jj)
for iii in LLL:
for jjj in G[iii]:
LLLL.append(jjj)
for iiii in LLLL:
if D[iiii]==0:
D[iiii]=1
l.append(iiii)
L,LL,LLL,LLLL=l,[],[],[]
l=[]
cnt+=1
print((-1)) | import sys
from collections import deque
input=sys.stdin.readline
n,m=list(map(int,input().split()))
G=[[] for _ in range(3*(n+1))]
for _ in range(m):
u,v=list(map(int,input().split()))
G[3*u].append(3*v+2)
G[3*u+1].append(3*v)
G[3*u+2].append(3*v+1)
s,t=list(map(int,input().split()))
Q=deque()
Q.append(s*3)
D=[-3 for _ in range(3*(n+1))]
D[s*3]=0
while Q:
q=Q.popleft()
for i in G[q]:
if D[i]==-3:
D[i]=D[q]+1
Q.append(i)
print((D[t*3]//3)) | 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()))
g = [[] for _ in range(3 * n)]
for u, v in uv:
a = u - 1
b = v - 1
g[a].append(n + b)
g[n+a].append(n*2 + b)
g[n*2+a].append(b)
#print(g)
s -= 1
t -= 1
ans = 0
temp = [s]
while 1:
ans += 1
next = []
for x in temp:
next = next + g[x]
g[x] = []
if len(next) == 0:
print((-1))
exit()
if t in next:
print((ans // 3))
exit()
temp = [] + list(set(next))
| n, m = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(m)]
s, t = list(map(int, input().split()))
g = [set() for _ in range(3 * n)]
for u, v in uv:
a = u - 1
b = v - 1
g[a].add(n + b)
g[n+a].add(n*2 + b)
g[n*2+a].add(b)
#print(g)
s -= 1
t -= 1
ans = 0
temp = set()
temp.add(s)
while 1:
ans += 1
next = set()
for x in temp:
for y in g[x]:
next.add(y)
g[x] = []
if len(next) == 0:
print((-1))
exit()
if t in next:
print((ans // 3))
exit()
temp = next
| p02991 |
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
def main():
N, M = LI()
graph = []
from collections import defaultdict
reversed_graph_dict = defaultdict(list)
for _ in range(M):
u, v = LI()
graph.append([u,v])
reversed_graph_dict[v].append(u)
S, T = LI()
# print(reversed_graph_dict)
import collections
def bfs(graph, root):
seen, queue = set([root]), collections.deque([[root, 0],])
while queue:
vertex, tries = queue.popleft()
tries += 1
# 三段先を見に行く。
first_step = graph[vertex]
second_step = []
for x in first_step:
second_step += graph[x]
third_step = []
for x in set(second_step):
third_step += graph[x]
for node in set(third_step):
if node == S:
print(tries)
return
if node not in seen:
seen.add(node)
queue.append([node, tries])
print((-1))
return
bfs(reversed_graph_dict, T)
main() | import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
def main():
N, M = LI()
graph = []
from collections import defaultdict
reversed_graph_dict = defaultdict(list)
for _ in range(M):
u, v = LI()
graph.append([u,v])
reversed_graph_dict[v].append(u)
S, T = LI()
# print(reversed_graph_dict)
import collections
def bfs(graph, root):
seen, queue = set([root]), collections.deque([[root, 0],])
first_step_seen = set([])
second_step_seen = set([])
while queue:
vertex, tries = queue.popleft()
tries += 1
# 三段先を見に行く。
first_step = graph[vertex]
second_step = []
for x in set(first_step) - first_step_seen:
second_step += graph[x]
first_step_seen |= set(first_step)
third_step = []
for x in set(second_step) - second_step_seen:
third_step += graph[x]
second_step_seen |= set(second_step)
for node in set(third_step):
if node == S:
print(tries)
return
if node not in seen:
seen.add(node)
queue.append([node, tries])
print((-1))
return
bfs(reversed_graph_dict, T)
main() | p02991 |
import sys
def p(*a):
s=" ".join(map(str,a))
#print(s)
sys.stderr.write(s+"\n")
#-------------------------------------------------------------------
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()))
#p("N,M",N,M)
#p("G",G)
#p("S,T",S,T)
# グラフGから、3つ先の到達点のグラフXを作る
X=[[] for _ in range(N+1) ] #=> [[], [], [], [], [], [], [], []]
for i in range(N+1):
g = G[i]
for g1 in g:
for g2 in G[g1]:
for g3 in G[g2]:
# if (not g3 in X[i]):
# X[i].append(g3)
X[i].append(g3)
#p("X",X)
# 訪問済み＆移動数の記録用マップ、Visitedを作る。未訪問は-1
V=[-1 for _ in range(N+1) ] #=> [[], [], [], [], [], [], [], []]
V[S]=0
# キューに行き先候補を入れて、
from collections import deque
Q = deque()
Q.append(S)
while Q:
fm = Q.popleft()
# p("fm, X[fm], Q ", fm, X[fm], Q)
for to in X[fm]:
# p(" to, V[to], Q ",to, V[to], Q)
b = (V[to]==-1) # 未訪問である
#b = b or (V[to]>(V[fm]+1)) # より短いステップ数である(＝既存の方が大きい)
if b:
V[to] = V[fm]+1 # 訪問ステップ数の記録
Q.append(to) # 次の訪問先として、キューに追加
# p("V ",V)
#ans = V[T] if V[T]>0 else -1
#print(ans)
print((V[T]))
| import sys
def p(*a):
s=" ".join(map(str,a))
#print(s)
sys.stderr.write(s+"\n")
#-------------------------------------------------------------------
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()))
#p("N,M",N,M)
#p("G",G)
#p("S,T",S,T)
# 訪問済み＆移動数の記録用マップ、Visitedを作る。未訪問は-1
V=[ [-1,-1,-1] for _ in range(N+1) ] #=> [ [-1,-1,-1], [-1,-1,-1], ... [-1,-1,-1] ]
V[S][0]=0
# キューに行き先候補を入れて、
from collections import deque
Q = deque()
Q.append([S,0])
while Q:
FM = Q.popleft()
fm = FM[0]
l = FM[1]
for to in G[fm]:
nl = (l+1)%3
b = (V[to][nl]==-1) # 未訪問である
#b = b or (V[to]>(V[fm]+1)) # より短いステップ数である(＝既存の方が大きい)
if b:
V[to][nl] = V[fm][l]+1 # 訪問ステップ数の記録
Q.append([to,nl]) # 次の訪問先として、キューに追加
ans = V[T][0]
if ans > -1: ans //= 3
print(ans)
| p02991 |
# ABC132 E
from collections import deque
f=lambda:list(map(int,input().split()))
N,M=f()
KKP=[[set([]) for _ in [0]*(N+1)] for _ in [0]*3]
for _ in [0]*M:
a,b=f()
KKP[0][a].add(b)
S,T=f()
for j in range(2):
# j:回数
for a in range(1,N+1):
# a:頂点
for b in KKP[j][a]:
# KKP[j][a]:aからj+1回でたどり着ける頂点
for c in KKP[0][b]:
# bから1回でたどり着ける頂点
KKP[j+1][a].add(c)
F=set([])
q=deque()
q.append((S,0))
res=-1
while q:
node,score=q.popleft()
if node in F:
continue
if T==node:
res=score
break
F.add(node)
for nnode in KKP[2][node]:
if nnode in F:
continue
q.append((nnode,score+1))
print(res) | # ABC132 E
from collections import deque
f=lambda:list(map(int,input().split()))
N,M=f()
KKP=[[[] for _ in [0]*(N+1)] for _ in [0]*3]
for _ in [0]*M:
a,b=f()
KKP[0][a].append(b)
S,T=f()
for j in range(2):
# j:回数
for a in range(1,N+1):
# a:頂点
for b in KKP[j][a]:
# KKP[j][a]:aからj+1回でたどり着ける頂点 b
for c in KKP[0][b]:
# bから1回でたどり着ける頂点 c
if not c in KKP[j+1][a]:
KKP[j+1][a].append(c)
F=set([])
q=deque()
q.append((S,0))
res=-1
while q:
node,score=q.popleft()
if node in F:
continue
if T==node:
res=score
break
F.add(node)
for nnode in KKP[2][node]:
if nnode in F:
continue
q.append((nnode,score+1))
print(res) | p02991 |
# ABC132 E
from collections import deque
f=lambda:list(map(int,input().split()))
N,M=f()
KKP=[[[] for _ in [0]*(N+1)] for _ in [0]*3]
for _ in [0]*M:
a,b=f()
KKP[0][a].append(b)
S,T=f()
for j in range(2):
# j:回数
for a in range(1,N+1):
# a:頂点
for b in KKP[j][a]:
# KKP[j][a]:aからj+1回でたどり着ける頂点 b
for c in KKP[0][b]:
# bから1回でたどり着ける頂点 c
if not c in KKP[j+1][a]:
KKP[j+1][a].append(c)
F=set([])
q=deque()
q.append((S,0))
res=-1
while q:
node,score=q.popleft()
if node in F:
continue
if T==node:
res=score
break
F.add(node)
for nnode in KKP[2][node]:
if nnode in F:
continue
q.append((nnode,score+1))
print(res) | # ABC132 E
from collections import deque
f=lambda:list(map(int,input().split()))
N,M=f()
G=[[] for _ in [0]*(N+1)]
for _ in [0]*M:
a,b=f()
G[a].append(b)
S,T=f()
S=(S,0)
T=(T,0)
q=deque()
q.append(S)
F=set()
res=-1
while q:
node,r=q.popleft()
if (node,r%3) in F:
continue
if (node,r%3) == T:
res=r//3
break
F.add((node,r%3))
for next_node in G[node]:
if (next_node,(r+1)%3) in F:
continue
q.append((next_node,r+1))
print(res) | p02991 |
NM=list(map(int,input().split()))
N=NM[0]
M=NM[1]
graph=[[0 for i in range(N)] for j in range(N)]
for i in range(M):
edge=list(map(int,input().split()))
graph[edge[0]-1][edge[1]-1]=1
ST=list(map(int,input().split()))
S=ST[0]-1
T=ST[1]-1
first=[]
second=[]
third=[]
able=[S]
step=0
while True:
first=[]
second=[]
third=[]
judge = 0
for i in range(len(able)):
for j in range(N):
if (graph[able[i]][j] == 1) and not (j in first):
first.append(j)
for i in range(len(first)):
for j in range(N):
if (graph[first[i]][j] == 1) and not (j in second):
second.append(j)
for i in range(len(second)):
for j in range(N):
if (graph[second[i]][j] == 1) and not (j in third):
third.append(j)
for i in range(len(third)):
if not third[i] in able:
able.append(third[i])
judge = 1
if judge == 0:
print((-1))
break
step+=1
if T in able:
print(step)
break
| NM=list(map(int,input().split()))
N=NM[0]
M=NM[1]
graph=[[] for j in range(N)]
for i in range(M):
edge=list(map(int,input().split()))
graph[edge[0]-1].append(edge[1]-1)
ST=list(map(int,input().split()))
S=ST[0]-1
T=ST[1]-1
first=[]
second=[]
third=[]
able=[S]
step=0
while True:
first=[]
second=[]
third=[]
judge = 0
for i in range(len(able)):
for j in range(len(graph[able[i]])):
if not (graph[able[i]][j] in first):
first.append(graph[able[i]][j])
for i in range(len(first)):
for j in range(len(graph[first[i]])):
if not (graph[first[i]][j] in second):
second.append(graph[first[i]][j])
for i in range(len(second)):
for j in range(len(graph[second[i]])):
if not (graph[second[i]][j] in third):
third.append(graph[second[i]][j])
for i in range(len(third)):
if not third[i] in able:
able.append(third[i])
judge = 1
if judge == 0:
print((-1))
break
step+=1
if T in able:
print(step)
break
| p02991 |
import sys
from collections import deque, defaultdict
import copy
import bisect
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
import math
N, M = list(map(int, input().split()))
uv = []
for i in range(M):
uv.append(list(map(int, input().split())))
S, T = list(map(int, input().split()))
G = [dict() for i in range(N+1)]
for i in range(N + 1):
G[i]["eda"] = []
G[i]["second"] = set()
G[i]["third"] = set()
G[i]["num"] = -1
for i in range(M):
G[uv[i][0]]["eda"].append(uv[i][1])
for i in range(N + 1):
for node in G[i]["eda"]:
G[i]["second"] = G[i]["second"] | set(G[node]["eda"])
for i in range(N + 1):
for node in G[i]["eda"]:
G[i]["third"] = G[i]["third"] | G[node]["second"]
node_set = [S]
G[S]["num"] = 0
times = 1
while True:
node_set2 = []
for node in node_set:
if T in G[node]["third"]:
print(times)
exit()
for node2 in G[node]["third"]:
if G[node2]["num"] == -1:
G[node2]["num"] = times
node_set2.append(node2)
if len(node_set2) == 0:
print((-1))
exit()
node_set = copy.deepcopy(node_set2)
times += 1 |
import sys
from collections import deque, defaultdict
import copy
import bisect
#sys.setrecursionlimit(10 ** 9)
import math
import heapq
from itertools import combinations, permutations
import sys
def input():
return sys.stdin.readline().strip()
N, M = list(map(int, input().split()))
graph = [[] for _ in range(3*N)]
for i in range(M):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
graph[u%(3*N)].append((v + N)%(3*N))
graph[(u + N) % (3 * N)].append((v+2*N)%(3*N))
graph[(u + 2*N) % (3 * N)].append(v % (3 * N))
S, T = list(map(int, input().split()))
S -= 1
T -= 1
dist = [1000000000000000000 for _ in range(3*N)]
que = deque([])
que.append(S)
dist[S] = 0
while len(que) > 0:
node = que.popleft()
for edge in graph[node]:
if dist[edge] > dist[node] + 1:
dist[edge] = dist[node] + 1
que.append(edge)
if dist[T] < 100000000000000:
print((dist[T]//3))
else:
print((-1)) | p02991 |
from sys import stdin
from collections import defaultdict
from collections import deque
N,M = list(map(int,stdin.readline().split()))
Cs = [tuple(map(int,stdin.readline().split())) for _ in range(M)]
S,T = list(map(int,stdin.readline().split()))
INF = 10 ** 15
# visit = [False] * ( (N + 1) * 3 )
dist = [-1] * ( (N) * 3 + 1 )
graph_connection = defaultdict(lambda :[])
graph_cost = defaultdict(lambda :defaultdict(lambda :INF))
#
# def dfs(v,dist_before):
#
# dist[v] = dist_before + 1
# next_vertexs = graph_connection[v]
# for next_v in next_vertexs :
# if dist[next_v] == -1:
# dfs(next_v,dist[v])
# return 0
#
for cost in Cs:
a,b= cost
for i in range(0,3):
from_v = a + (i) * N
to_v = b + (i + 1) % 3 * N
graph_connection[from_v].append(to_v )
# from_v = b + (i) * N
# to_v = a + (i + 1) % 3 * N
# graph_connection[from_v].append(to_v )
# dist[S] = 0
que = deque()
#(from_v,to_v)
que.append((S,S))
while len(que) != 0:
from_v, to_v = que.popleft()
dist[to_v] = dist[from_v] + 1
if to_v == T:
break
for next_v in graph_connection[to_v]:
if dist[next_v] == -1:
que.append((to_v,next_v))
if dist[T] < 0:
print((dist[T] ))
else:
print((dist[T]//3))
| from sys import stdin
from collections import defaultdict
from collections import deque
N,M = list(map(int,stdin.readline().split()))
Cs = [tuple(map(int,stdin.readline().split())) for _ in range(M)]
S,T = list(map(int,stdin.readline().split()))
INF = 10 ** 15
# visit = [False] * ( (N + 1) * 3 )
dist = [-1] * ( (N) * 3 + 1 )
graph_connection = defaultdict(lambda :[])
graph_cost = defaultdict(lambda :defaultdict(lambda :INF))
#
# def dfs(v,dist_before):
#
# dist[v] = dist_before + 1
# next_vertexs = graph_connection[v]
# for next_v in next_vertexs :
# if dist[next_v] == -1:
# dfs(next_v,dist[v])
# return 0
#
for cost in Cs:
a,b= cost
for i in range(0,3):
from_v = a + (i) * N
to_v = b + (i + 1) % 3 * N
graph_connection[from_v].append(to_v )
# from_v = b + (i) * N
# to_v = a + (i + 1) % 3 * N
# graph_connection[from_v].append(to_v )
# dist[S] = 0
que = deque()
#(from_v,to_v)
dist[S] = 0
que.append(S)
while len(que) != 0:
from_v = que.popleft()
nexts = graph_connection[from_v]
for next_v in nexts:
if dist[next_v] == -1:
dist[next_v] = dist[from_v] + 1
que.append(next_v)
if dist[T] < 0:
print((dist[T] ))
else:
print((dist[T]//3))
| p02991 |
import sys
import heapq
import math
input = sys.stdin.readline
N, M = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(M)]
S, T = list(map(int, input().split()))
g = [[] for _ in range(3*N)]
for a, b in uv:
g[a-1].append(b-1+N)
g[a-1+N].append(b-1+2*N)
g[a - 1 + 2 * N].append(b - 1)
# bfsでよかった
hq = [(0, S-1)]
costs = [math.inf] * 3 * N
while len(hq) > 0:
c, u = heapq.heappop(hq)
if u == T - 1:
print((c // 3))
sys.exit()
costs[u] = c
for v in g[u]:
if costs[v] > c+1:
heapq.heappush(hq, (c + 1, v))
print((-1))
| import sys
import heapq
import math
input = sys.stdin.readline
N, M = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(M)]
S, T = list(map(int, input().split()))
g = [[] for _ in range(3*N)]
for a, b in uv:
g[a-1].append(b-1+N)
g[a-1+N].append(b-1+2*N)
g[a - 1 + 2 * N].append(b - 1)
# bfsでよかった
hq = [(0, S-1)]
costs = [math.inf] * 3 * N
while len(hq) > 0:
c, u = heapq.heappop(hq)
if u == T - 1:
print((c // 3))
sys.exit()
costs[u] = c
for v in g[u]:
if costs[v] > c+1:
heapq.heappush(hq, (c + 1, v))
costs[v] = min(costs[v], c+1)
print((-1))
| p02991 |
import sys
import re
import math
import collections
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
nb = lambda: list([int(x) - 1 for x in sys.stdin.readline().split()])
# ===CODE===
def main():
n, m = ns()
e = [[] for _ in range(n)]
for _ in range(m):
a, b = ns()
a, b = a - 1, b - 1
e[a].append(b)
s, t = ns()
s, t = s - 1, t - 1
ans = -1
que = collections.deque(e[s])
cnt = 0
finflg = True
while len(que) and cnt < 3*10 ** 5 and finflg:
cnt += 1
finflg = True
for _ in range(3):
for i in range(len(que)):
nxt = que.popleft()
if _ == 2 and nxt == t:
ans = cnt
finflg = False
for tmp in e[nxt]:
que.append(tmp)
print((-1 if ans == -1 else ans))
if __name__ == '__main__':
main()
| import sys
import re
import math
import collections
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
nb = lambda: list([int(x) - 1 for x in sys.stdin.readline().split()])
# ===CODE===
def main():
n, m = ns()
e = [[] for _ in range(n)]
for _ in range(m):
a, b = ns()
a, b = a - 1, b - 1
e[a].append(b)
s, t = ns()
s, t = s - 1, t - 1
e3 = [[] for _ in range(n)]
for i in range(n):
que = collections.deque(e[i])
for _ in range(2):
for __ in range(len(que)):
tmp = que.popleft()
for ei in e[tmp]:
que.append(ei)
tmp = set(que)
tmp -= {i}
e3[i] = list(tmp)
ans = -1
cnt = 1
que = collections.deque(e3[s])
finflg = True
while len(que) and finflg and cnt < 10 ** 5+1:
cnt += 1
for _ in range(len(que)):
q = que.popleft()
for ei in e3[q]:
que.append(ei)
if ei == t:
finflg = False
ans = cnt
print((ans if ans != -1 else -1))
if __name__ == '__main__':
main()
| p02991 |
from collections import defaultdict
import sys
input = sys.stdin.readline
inpl = lambda: list(map(int,input().split()))
N, M = inpl()
uv = [ set() for _ in range(N) ]
for _ in range(M):
u, v = inpl()
uv[u-1].add(v-1)
S, T = inpl()
S -= 1
T -= 1
cur = set({S})
for i in range(3*N-2):
if i % 3 == 0 and T in cur:
print((i//3))
break
prev = cur
cur = set()
for p in prev:
cur |= uv[p]
else:
print((-1)) | import sys
input = sys.stdin.readline
inpl = lambda: list(map(int,input().split()))
N, M = inpl()
uv = [ set() for _ in range(3*N) ]
vu = [ set() for _ in range(3*N) ]
for _ in range(M):
u, v = inpl()
for k in range(3):
uv[u-1 + k*N].add(v-1 + ((k+1)%3)*N)
vu[v-1 + ((k+1)%3)*N].add(u-1 + k*N)
S, T = inpl()
S -= 1
T -= 1
cur = set({S})
for i in range(3*N):
if i % 3 == 0 and T in cur:
print((i//3))
break
elif len(cur) == 0:
print((-1))
break
prev = cur
cur = set()
for u in prev:
for fr in vu[u]:
uv[fr].remove(u)
cur |= uv[u]
else:
print((-1)) | p02991 |
import sys
input=sys.stdin.buffer.readline
inputs=sys.stdin.buffer.readlines
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
edges=[[] for i in range(3+3*n)]
for i in range(m):
"""#weighted->erase_,__,___=map(int,input().split())
edges[_].append((__,___))
#undirected->erase#edges[__].append((_,___))
"""
_,__=list(map(int,input().split()))
_*=3;__*=3
edges[_].append(__+1)
edges[_+1].append(__+2)
edges[_+2].append(__)
#undirected->erase#edges[__].append(_)
"""
"""#weighted->erase
s,T=list(map(int,input().split()))
from collections import deque
dq=deque([])
dq.append((3*s,0))
T*=3
seen=set()
seen.add(3*s)
while dq:
now,c=dq.popleft()
if now==T :print((c//3));exit()
for t in edges[now]:
if t not in seen:
dq.append((t,c+1))
seen.add(now)
print("-1")
| import sys
input=sys.stdin.buffer.readline
inputs=sys.stdin.buffer.readlines
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
edges=[[] for i in range(3+3*n)]
o=inputs()
s,T=list(map(int,o.pop().split()))
for i in o:
_,__=list(map(int,i.split()))
_*=3;__*=3
edges[_].append(__+1)
edges[_+1].append(__+2)
edges[_+2].append(__)
from collections import deque
dq=deque([])
dq.append((3*s,0))
T*=3
seen=[0]*(3*n+3)
seen[3*s]=1
while dq:
now,c=dq.popleft()
if now==T :print((c//3));exit()
for t in edges[now]:
if seen[t]==0:
dq.append((t,c+1))
seen[t]=1
print("-1")
| p02991 |
import sys
input=sys.stdin.buffer.readline
inputs=sys.stdin.buffer.readlines
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
edges=[[] for i in range(3+3*n)]
o=inputs()
s,T=list(map(int,o.pop().split()))
for i in o:
"""#weighted->erase_,__,___=map(int,input().split())
edges[_].append((__,___))
#undirected->erase#edges[__].append((_,___))
"""
_,__=list(map(int,i.split()))
_*=3;__*=3
edges[_].append(__+1)
edges[_+1].append(__+2)
edges[_+2].append(__)
#undirected->erase#edges[__].append(_)
"""
"""#weighted->erase
from collections import deque
dq=deque([])
dq.append((3*s,0))
T*=3
seen=set()
seen.add(3*s)
while dq:
now,c=dq.popleft()
if now==T :print((c//3));exit()
for t in edges[now]:
if t not in seen:
dq.append((t,c+1))
seen.add(now)
print("-1")
| import sys
input=sys.stdin.buffer.readline
inputs=sys.stdin.buffer.readlines
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
edges=[[] for i in range(3+3*n)]
o=inputs()
s,T=list(map(int,o.pop().split()))
for i in o:
_,__=list(map(int,i.split()))
_*=3;__*=3
edges[_].append(__+1)
edges[_+1].append(__+2)
edges[_+2].append(__)
from collections import deque
dq=deque([])
dq.append((3*s,0))
T*=3
seen=set()
seen.add(3*s)
while dq:
now,c=dq.popleft()
if now==T :print((c//3));exit()
for t in edges[now]:
if t not in seen:
dq.append((t,c+1))
seen.add(t)
print("-1")
| p02991 |
from collections import deque
n,m = list(map(int,input().split()))
l = [[] for i in range(n+1)]
rl = [0 for i in range(n+1)]
for i in range(m):
u,v = list(map(int,input().split()))
l[u].append(v)
s,t = list(map(int,input().split()))
d = deque()
d.append([s,0])
rl[s] = 1
ans = -1
def kkp(l,rl,now,d,c,t):
for i in l[now]:
for j in l[i]:
for k in l[j]:
#print(k,now,c)
if k == t:
return c+1
else:
if rl[k] == 0:
d.append([k,c+1])
rl[k] = 1
return 0
while len(d):
now,c = d.popleft()
if m == 0:
break
else:
if kkp(l,rl,now,d,c,t) > 0:
ans = kkp(l,rl,now,d,c,t)
break
print(ans) | from collections import deque
n,m = list(map(int,input().split()))
l = [[] for i in range(n+1)]
rl = [[-1 for i in range(n+1)] for i in range(3)]
for i in range(m):
u,v = list(map(int,input().split()))
l[u].append(v)
s,t = list(map(int,input().split()))
d = deque()
ans = -1
d.append([s,0])
rl[0][s] = 0
while len(d):
now,count = d.popleft()
for i in l[now]:
if i == t and count % 3 == 2:
ans = (count + 1)//3
break
else:
if rl[(count%3 + 1)%3][i] == -1:
d.append([i,count+1])
rl[(count%3+1)%3][i] = count+1
if ans >= 0:
break
print(ans) | p02991 |
import sys #追加
sys.setrecursionlimit(500*500) #追加
n,m=list(map(int,input().split()))
edge = [[] for i in range(n*3)]
#edge[i] : iから出る道の[行先]の配列
for i in range(m):
x,y = list(map(int,input().split()))
x-=1;y-=1
x*=3;y*=3
edge[x ].append(y+1)
edge[x+1].append(y+2)
edge[x+2].append(y )
def dfs(s,g,res):
if s==g or s==g+1 or s==g+2:
if res%3==0:
return res//3
if res>m*3:
return float("inf")
l=float("inf")
for i in edge[s]:
l=min(l,dfs(i,g,res+1))
return l
s,t=list(map(int,input().split()))
s-=1;t-=1
ans=dfs(s*3,t*3,0)
if ans==float("inf"):
print((-1))
else:
print(ans)
| from collections import deque
n,m=list(map(int,input().split()))
edge = [[] for i in range(n+1)]
#edge[i] : iから出る道の[行先]の配列
for _ in range(m):
u, v = list(map(int, input().split()))
edge[u].append(v)
s,t = list(map(int, input().split()))
queue = deque()
queue.append((s, 0))
visited = [[False] * 3 for _ in range(n+1)]
while queue:
u, d = queue.popleft()
if visited[u][d % 3]:
continue
visited[u][d % 3] = True
if d % 3 == 0 and u == t:
print((d // 3));exit()
for v in edge[u]:
queue.append((v, d+1))
print((-1)) | p02991 |
N,M = list(map(int, input().split()))
g = {}
for v in range(1,N*3+1):
g[v] = []
for _ in range(M):
u,v = list(map(int, input().split()))
g[u + N*0].append(v + N*1)
g[u + N*1].append(v + N*2)
g[u + N*2].append(v + N*0)
S,T = list(map(int, input().split()))
visiting = [(S,0)]
visited = {}
while visiting:
v,d = visiting.pop(0)
if v in visited:
continue
visited[v] = d
if v == T:
break
for v2 in g[v]:
if v2 in visiting or v2 in visited:
continue
visiting.append((v2,d+1))
if T in visited:
print((visited[T] // 3))
else:
print((-1))
| N,M = list(map(int, input().split()))
g = {}
for v in range(1,N*3+1):
g[v] = []
for _ in range(M):
u,v = list(map(int, input().split()))
g[u + N*0].append(v + N*1)
g[u + N*1].append(v + N*2)
g[u + N*2].append(v + N*0)
S,T = list(map(int, input().split()))
visiting = [S]
visited = {S:0}
while visiting:
v = visiting.pop(0)
if v == T:
break
for v2 in g[v]:
if v2 not in visited:
visiting.append(v2)
visited[v2] = visited[v]+1
if T in visited:
print((visited[T] // 3))
else:
print((-1))
| p02991 |
from collections import deque
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 -= 1; v -= 1
graph[u].append(v)
S, T = list(map(int, input().split()))
S -= 1; T -= 1
memo = {}
def search(node, k):
global memo
s = set()
if k == 0:
return set([node])
if (node, k) in memo:
return memo[(node, k)]
children = graph[node]
for child in children:
s |= search(child, k-1)
memo[(node, k)] = s
return s
# 距離が3のノード間にだけ辺を張り直す
g = [[] for i in range(N)]
for i in range(N):
g[i] = search(i, 3)
dist = [-1] * N
dist[S] = 0
d = deque([[S, -1]])
while d:
node, par = d.popleft()
children = g[node]
for child in children:
if dist[child] < 0:
dist[child] = dist[node] + 1
d.append([child, node])
if dist[T] > 0:
print((dist[T]))
else:
print((-1)) | from collections import deque
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 -= 1; v -= 1
graph[3*u].append(3*v+1)
graph[3*u+1].append(3*v+2)
graph[3*u+2].append(3*v)
S, T = list(map(int, input().split()))
S -= 1; T -= 1
dist = [-1] * (3*N)
dist[3*S] = 0
d = deque([3*S])
while d:
node = d.popleft()
children = graph[node]
for child in children:
if dist[child] < 0:
dist[child] = dist[node] + 1
d.append(child)
if dist[3*T] > 0:
print((dist[3*T] // 3))
else:
print((-1)) | p02991 |
#!/usr/bin/env python3
import sys
import heapq
from collections import defaultdict
def solve(N: int, M: int, U: "List[int]", V: "List[int]", S: int, T: int):
S -= 1
T -= 1
adj = [[] for i in range(N)]
for u, v in zip(U, V):
adj[u-1].append(v-1)
color = [[] for i in range(N)]
color[S] = [0]
Q = [(0, S)]
while len(Q) > 0:
d, u = heapq.heappop(Q)
if u == T and d % 3 == 0:
print((d // 3))
return
for v in adj[u]:
if (d+1) % 3 in color[v]:
continue
heapq.heappush(Q, (d+1, v))
color[v].append(d+1 % 3)
print((-1))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
u = [int()] * (M) # type: "List[int]"
v = [int()] * (M) # type: "List[int]"
for i in range(M):
u[i] = int(next(tokens))
v[i] = int(next(tokens))
S = int(next(tokens)) # type: int
T = int(next(tokens)) # type: int
solve(N, M, u, v, S, T)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import heapq
from collections import defaultdict
def solve(N: int, M: int, U: "List[int]", V: "List[int]", S: int, T: int):
S -= 1
T -= 1
adj = [[] for i in range(N)]
for u, v in zip(U, V):
adj[u-1].append(v-1)
color = [[0, 0, 0] for i in range(N)]
color[S][0] = 1
Q = [(0, S)]
while len(Q) > 0:
d, u = heapq.heappop(Q)
if u == T and d % 3 == 0:
print((d // 3))
return
for v in adj[u]:
if color[v][(d+1) % 3] == 1:
continue
heapq.heappush(Q, (d+1, v))
color[v][(d+1) % 3] = 1
print((-1))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
u = [int()] * (M) # type: "List[int]"
v = [int()] * (M) # type: "List[int]"
for i in range(M):
u[i] = int(next(tokens))
v[i] = int(next(tokens))
S = int(next(tokens)) # type: int
T = int(next(tokens)) # type: int
solve(N, M, u, v, S, T)
if __name__ == '__main__':
main()
| p02991 |
N,M=list(map(int,input().split()))
E=[[] for i in range(N)]
for i in range(M):
u,v=list(map(int,input().split()))
u,v=u-1,v-1
E[u].append(v)
S,T=list(map(int,input().split()))
S,T=S-1,T-1
from collections import deque
stack=deque()
seen=[[False for i in range(3)] for j in range(N)]
stack.append([S,0,1])
while stack:
node=stack.popleft()
v=node[0]
step=node[1]
turn=node[2]
if step==3:
if v==T:
print(turn)
break
step=0
turn+=1
if seen[v][step]:
continue
seen[v][step]=True
children=E[v]
for child in children:
stack.append([child,step+1,turn])
else:
print((-1))
| N,M=list(map(int,input().split()))
E=[[] for i in range(N)]
for i in range(M):
u,v=list(map(int,input().split()))
u,v=u-1,v-1
E[u].append(v)
S,T=list(map(int,input().split()))
S,T=S-1,T-1
from collections import deque
q=deque()
seen=[[False for i in range(3)] for j in range(N)]
q.append([S,0,1])
while q:
node=q.popleft()
v=node[0]
step=node[1]
turn=node[2]
if step==3:
if v==T:
print(turn)
break
step=0
turn+=1
if seen[v][step]:
continue
seen[v][step]=True
children=E[v]
for child in children:
q.append([child,step+1,turn])
else:
print((-1))
| p02991 |
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(eval(input()))
def inpm(): return list(map(int,input().split()))
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(eval(input())) for _ in range(n))
def inplL(n): return [list(eval(input())) for _ in range(n)]
def inplT(n): return [tuple(eval(input())) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
def main():
n,m = inpm()
g = [[] for _ in range(n)]
for _ in range(m):
u,v = inpm()
u -= 1
v -= 1
g[u].append(v)
visited = [0 for _ in range(n)]
s,t = inpm()
s -= 1
t -= 1
que = deque()
que.append(s)
visited[s] = 1
cnt = 1
while True:
key = 1
for _ in range(3):
tank = deque()
while que:
start = que.pop()
for go in g[start]:
tank.append(go)
que = tank
tank = deque()
for e in que:
if not visited[e]:
visited[e] = 1
tank.append(e)
key = 0
if e == t:
print(cnt)
return
que = tank
cnt += 1
if key:
break
print((-1))
if __name__ == "__main__":
main() | import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(eval(input()))
def inpm(): return list(map(int,input().split()))
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(eval(input())) for _ in range(n))
def inplL(n): return [list(eval(input())) for _ in range(n)]
def inplT(n): return [tuple(eval(input())) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
def main():
n,m = inpm()
g = [[] for _ in range(n)]
for _ in range(m):
u,v = inpm()
u -= 1
v -= 1
g[u].append(v)
s,t = inpm()
s -= 1
t -= 1
que = deque()
que.append(s)
visited1 = [0 for _ in range(n)]
visited2 = [0 for _ in range(n)]
visited3 = [0 for _ in range(n)]
visited3[s] = 1
cnt = 1
while True:
tank1 = deque()
tank2 = deque()
tank3 = deque()
while que:
start = que.pop()
for go in g[start]:
if not visited1[go]:
visited1[go] = 1
tank1.append(go)
while tank1:
start = tank1.pop()
for go in g[start]:
if not visited2[go]:
visited2[go] = 1
tank2.append(go)
while tank2:
start = tank2.pop()
for go in g[start]:
if not visited3[go]:
visited3[go] = 1
tank3.append(go)
if go == t:
print(cnt)
return
que = tank3
cnt += 1
if que == deque():
break
print((-1))
if __name__ == "__main__":
main() | p02991 |
N, M = [int(x) for x in input().strip().split(" ")]
vs = set()
def dfs_w(v, d, t):
# dfs while版
r = -1
stack = [v]
path = []
while True:
if len(stack) == 0:
break
v = stack.pop()
if v < 0:
path.pop()
else:
path.append(v)
vs.add(v)
for u in d[v]:
if u == t:
#print(r,path)
if r != -1:
r = min(len(path)//3, r)
else:
r = len(path)//3
#continue
if u in vs:
continue
stack += [-v, u]
return r
from collections import deque
def bfs(v,d,t,N):
queue=deque([v])
dist = [0] * (N+1)
while True:
if len(queue) == 0:
break
v = queue.popleft()
vs.add(v)
for u in d[v]:
if u in vs:
continue
dist[u] = dist[v] + 1
if u == t:
return dist[u]//3
queue.append(u)
return -1
d = [set() for _ in range(3*N+1)]
for _ in range(M):
a, b = [int(x) for x in input().strip().split(" ")]
d[a].add(N+b)
d[N+a].add(2*N+b)
d[2*N+a].add(b)
s, t = [int(x) for x in input().strip().split(" ")]
print((bfs(s, d, t, 3*N+1))) | N, M = [int(x) for x in input().strip().split(" ")]
from collections import deque
vs = set()
def bfs(v,d,t,N):
queue=deque([v])
dist = [0] * (N+1)
while True:
if len(queue) == 0:
break
v = queue.popleft()
for u in d[v]:
if u in vs:
continue
vs.add(u)
dist[u] = dist[v] + 1
if u == t:
return dist[u]//3
queue.append(u)
return -1
d = [set() for _ in range(3*N+1)]
for _ in range(M):
a, b = [int(x) for x in input().strip().split(" ")]
d[a].add(N+b)
d[N+a].add(2*N+b)
d[2*N+a].add(b)
s, t = [int(x) for x in input().strip().split(" ")]
print((bfs(s, d, t, 3*N+1)))
| p02991 |
N, M = [int(x) for x in input().strip().split(" ")]
from collections import deque
vs = set()
def bfs(v,d,t,N):
queue=deque([v])
dist = [0] * (N+1)
while True:
if len(queue) == 0:
break
v = queue.popleft()
for u in d[v]:
if u in vs:
continue
vs.add(u)
dist[u] = dist[v] + 1
if u == t:
return dist[u]//3
queue.append(u)
return -1
d = [set() for _ in range(3*N+1)]
for _ in range(M):
a, b = [int(x) for x in input().strip().split(" ")]
d[a].add(N+b)
d[N+a].add(2*N+b)
d[2*N+a].add(b)
s, t = [int(x) for x in input().strip().split(" ")]
print((bfs(s, d, t, 3*N+1)))
| N,M=list(map(int,input().split()))
edge=[list(map(int,input().split())) for i in range(M)]
inf=10**20
c=[[] for i in range(N*3+1)]
for i,j in edge:
c[i].append(N+j)
c[N+i].append(N+N+j)
c[N+N+i].append(j)
S,T=list(map(int, input().split()))
from collections import deque
d=[inf]*(N*3+1)
d[S]=0
q=deque([S])
x=1
while q:
q2=deque()
for i in q:
for j in c[i]:
if d[j]>x:
d[j]=x
q2.append(j)
q=q2
x+=1
print((d[T]//3 if d[T]<inf else -1))
| p02991 |
import heapq
N,M = list(map(int,input().split()))
edge = [[] for i in range(N)]
double_edge = [[] for i in range(N)]
triple_edge = [[] for i in range(N)]
for i in range(M):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
edge[u].append(v)
S,T = list(map(int,input().split()))
S -= 1
T -= 1
for i in range(N):
e = edge[i]
l = []
for x in e:
l += edge[x]
double_edge[i] = list(set(l))
for i in range(N):
e = edge[i]
l = []
for x in e:
l += double_edge[x]
l = list(set(l))
if i in l:
l.remove(i)
triple_edge[i] = l
INF = 10**10
dist = [INF if i != S else 0 for i in range(N)]
search = []
searched = [False for i in range(N)]
heapq.heapify(search)
heapq.heappush(search, (0,S))
while len(search) > 0 and dist[T] == INF:
x = heapq.heappop(search)
d, node = x[0], x[1]
if searched[node]:
continue
searched[S] = True
dist[node] = d
for i in triple_edge[node]:
if not searched[i]:
heapq.heappush(search, (min(d+1, dist[i]), i))
if dist[T] < INF:
print((dist[T]))
else:
print((-1)) | import heapq
N,M = list(map(int,input().split()))
edge = [[[] for i in range(N)] for j in range(3)]
for i in range(M):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
edge[0][u].append(v)
edge[1][u].append(v)
edge[2][u].append(v)
S,T = list(map(int,input().split()))
S -= 1
T -= 1
INF = 10**10
dist = [[0 if i == S and j == 0 else INF for i in range(N)] for j in range(3)]
search = []
searched = [[False for i in range(N)] for j in range(3)]
heapq.heapify(search)
heapq.heappush(search, (0, 0, S))
while len(search) > 0 and dist[0][T] == INF:
x = heapq.heappop(search)
d, t, node = x[0], x[1], x[2]
if searched[t][node]:
continue
searched[t][node] = True
dist[t][node] = d
for i in edge[t][node]:
if not searched[(t+1)%3][i]:
heapq.heappush(search, (d+(t+1)//3, (t+1) % 3, i))
if dist[0][T] < INF:
print((dist[0][T]))
else:
print((-1)) | p02991 |
from collections import deque
n,m = list(map(int,input().split()))
graph = [[[] for i in range(3)] for j in range(n+1)]
for i in range(m):
u,v = list(map(int,input().split()))
graph[u][0].append(v)
s,t = list(map(int,input().split()))
for i in range(1,3):
for j in range(1,n+1):
l = set([])
for k in graph[j][0]:
l = l | set(graph[k][i-1])
graph[j][i] = list(l)
for i in range(n+1):
graph[i] = graph[i][2]
cnt = 0
done = [0]*(n+1)
done[s] = 1
wait = deque([s])
while wait:
cnt += 1
q = wait
wait = deque([])
for i in q:
for j in graph[i]:
if not done[j]:
wait.append(j)
done[j] = 1
if j == t:
print(cnt)
quit()
print((-1)) | import copy
n,m = list(map(int,input().split()))
graph = [[] for _ in range(n*3)]
for i in range(m):
u,v = list(map(int,input().split()))
for j in range(3):
graph[n*j+u-1].append((n*(j+1)+v-1)%(3*n))
s,t = list(map(int,input().split()))
wait = [s-1]
cnt = 0
done = [0]*(3*n)
while wait:
cnt += 1
now = copy.copy(wait)
wait = []
for i in now:
for j in graph[i]:
if not done[j]:
done[j] = 1
wait.append(j)
if j == t-1:
print((cnt//3))
quit()
print((-1)) | p02991 |
from collections import deque
N,M = list(map(int,input().split()))
edges = []
ad = [[] for _ in range(N)]
for _ in range(M):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
ad[u].append(v)
edges.append((u,v))
S,T = list(map(int,input().split()))
S -= 1
T -= 1
dq = deque()
dq.append((S,0))
while dq:
v,d = dq.popleft()
nd = d + 1
for nv in ad[v]:
if nv == T and nd % 3 == 0:
print((nd//3))
exit()
if d == 3*10**5:
print((-1))
exit()
dq.append((nv,nd))
print((-1)) | from collections import deque
N,M = list(map(int,input().split()))
ad = [[[] for _ in range(3)] for _ in range(N)]
for _ in range(M):
u,v = list(map(int,input().split()))
u -= 1
v -= 1
for j in range(3):
ad[u][j].append((v,(j+1)%3))
S,T = list(map(int,input().split()))
S -= 1
T -= 1
visited = [[False]*3 for _ in range(N)]
dq = deque()
dq.append((S,0,0))
visited[S][0] = True
while dq:
v,j,d = dq.popleft()
nd = d + 1
for nv,nj in ad[v][j]:
if (nv,nj) == (T,0):
print((nd//3))
exit()
if visited[nv][nj]:
continue
visited[nv][nj] = True
dq.append((nv,nj,nd))
print((-1)) | p02991 |
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 30 09:04:16 2018
@author: Yamazaki Kenichi
"""
L,N = list(map(int, input().split(' ')))
X = [int(eval(input())) for i in range(N) ]
Xr = [0] + X
Yr = ["d"]
for i in range(0,N):
Yr.append( Xr[i+1] - Xr[i])
Yl = ["d"]+[L-X[N-1]]
Yl += Yr[::-1]
S = []
answer = 0
for itr in range(1,N+1):
sum = 0
counter = 1
while counter <= itr:
sum += Yr[counter]
counter += 1
turn = counter-1
counter2 = 1
sum2 = sum
while counter <= N:
if counter2 % 2 ==1:
sum2 += Yl[counter2//2+1]
sum += sum2
else:
sum2 += Yr[turn + counter2//2]
sum += sum2
counter += 1
counter2 += 1
# print(sum)
# S.append(sum)
answer = max(answer,sum)
for itr in range(1,N+1):
sum = 0
counter = 1
while counter <= itr:
sum += Yl[counter]
counter += 1
turn = counter-1
counter2 = 1
sum2 = sum
while counter <= N:
if counter2 % 2 ==1:
sum2 += Yr[counter2//2+1]
sum += sum2
else:
sum2 += Yl[turn + counter2//2]
sum += sum2
counter += 1
counter2 += 1
answer = max(answer,sum)
print(answer)
| # -*- coding: utf-8 -*-
"""
Created on Sun Dec 30 09:04:16 2018
@author: Yamazaki Kenichi
"""
L,N = list(map(int, input().split(' ')))
X = [int(eval(input())) for i in range(N) ]
#inp = input().split()
#inp = [int(i) for i in inp]
#L, N = inp[0],inp[1]
#X = inp[2:]
X = [0] + X
temp = L - X[1]
ans = temp
itr1 = 0
itr2 = N
a = N%2
for i in range(-(N-1),N):
if (i+a)%2 == 1:
itr1 += 1
else:
itr2 -= 1
if X[i]-X[i-itr1] >=0:
minus = X[i]-X[i-itr1]
else:
minus = L+(X[i]-X[i-itr1])
if X[i+itr2]-X[i] >=0:
plus = X[i+itr2]-X[i]
else:
plus = L+(X[i+itr2]-X[i])
temp = temp - minus + plus
# print(temp)
ans = max(ans,temp)
print(ans)
| p03187 |
import sys
INF = float('inf')
L, N = list(map(int, input().split()))
Xs = [0] + [int(eval(input())) for _ in range(N)] + [L]
if N == 1:
print((max(Xs[1], L - Xs[1])))
sys.exit()
dp = [[[-INF] * (2) for B in range(N+1)] for A in range(N+1)]
dp[1][N][0] = 0
dp[1][N][1] = 0
for A in range(1, N+1):
for B in reversed(list(range(A, N+1))):
# C=0 ccw
C = 0
if B > 1: # ccw
dp[A][B-1][0] = max(dp[A][B-1][0], dp[A][B][C] + Xs[B+1] - Xs[B])
if A < N: # cw
dp[A+1][B][1] = max(dp[A+1][B][1], dp[A][B][C] + (L - Xs[B+1]) + Xs[A])
# C=1 cw
C = 1
if B > 1: # ccw
dp[A][B-1][0] = max(dp[A][B-1][0], dp[A][B][C] + Xs[A-1] + (L - Xs[B]))
if A < N: # cw
dp[A+1][B][1] = max(dp[A+1][B][1], dp[A][B][C] + Xs[A] - Xs[A-1])
ans = 0
for A in range(N+1):
for B in range(N+1):
for C in range(2):
ans = max(ans, dp[A][B][C])
print(ans)
| from itertools import accumulate
def getRangeSum(accXs, iFr, iTo):
return accXs[iTo+1] - accXs[iFr]
def getAns(accXs, accRevXs, Xs, revXs):
ans = 0
for i in range(N):
num = (N-i)//2
dist = 2 * getRangeSum(accXs, i, i + num-1)
dist += 2 * getRangeSum(accRevXs, 0, num-1)
if (N-i)%2 == 0:
dist -= revXs[num-1]
else:
dist += Xs[i + num]
ans = max(ans, dist)
return ans
L, N = list(map(int, input().split()))
Xs = [int(eval(input())) for _ in range(N)]
revXs = [L-X for X in reversed(Xs)]
accXs = [0] + list(accumulate(Xs))
accRevXs = [0] + list(accumulate(revXs))
print((max(getAns(accXs, accRevXs, Xs, revXs), getAns(accRevXs, accXs, revXs, Xs))))
| p03187 |
L, N = list(map(int, input().split()))
X = [int(eval(input())) for i in range(N)]
## Y[i] = X[i+1]-X[i]
#Y = [X[i+1]-X[i] if i<N-1 else L+X[0]-X[N-1] for i in range(N)]
#print(Y)
''' Start at X[0] '''
#''' In the case when turn first '''
#ans0 = X[0]
## 0, -1, 1, -2, ...
#i = 0
#j = N-1
#direc = 1 # direction: left->1, right->-1
#while i!=j:
# print(i, j)
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
#ans0 = X[1]
#i = 1
#j = N-1
#direc = 1 # direction: left->1, right->-1
#while i!=j:
# print(i, j)
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
#ans0 = X[2]
#i = 2
#j = N-1
#direc = 1 # direction: left->1, right->-1
#while i!=j:
# print(i, j)
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
## 0, -1, 1, -2, 2, ...
## 0, 1, -1, 2, -2, 3, ...
ans0 = 0
for k in range(N):
tmp_ans = X[k]
i = k
j = N-1
direc = 1 # direction: left->1, right->-1
while i!=j:
direc *= -1
tmp_ans += L+X[i]-X[j]
if direc==-1:
i += 1
elif direc==1:
j -= 1
if ans0<tmp_ans:
ans0 = tmp_ans
ans1 = 0
for k in reversed(list(range(N))):
tmp_ans = L-X[k]
i = 0
j = k
direc = -1 # direction: left->1, right->-1
while i!=j:
direc *= -1
tmp_ans += L+X[i]-X[j]
if direc==-1:
i += 1
elif direc==1:
j -= 1
if ans1<tmp_ans:
ans1 = tmp_ans
print((max(ans0, ans1)))
| L, N = list(map(int, input().split()))
X = [int(eval(input())) for i in range(N)]
## Y[i] = X[i+1]-X[i]
#Y = [X[i+1]-X[i] if i<N-1 else L+X[0]-X[N-1] for i in range(N)]
#print(Y)
''' Start at X[0] '''
''' In the case when turn first '''
ans0 = X[0]
# 0, -1, 1, -2, ...
i = 0
j = N-1
direc = 1 # direction: left->1, right->-1
while i!=j:
direc *= -1
ans0 += L+X[i]-X[j]
if direc==-1:
i += 1
elif direc==1:
j -= 1
if N%2==0:
i = N//2
j = N//2
else:
i = N//2
j = N//2+1
tmp_ans = ans0
for k in range(N-1):
tmp_ans += -L-2*X[k]+X[i]+X[j]
if i==j:
j += 1
else:
i += 1
ans0 = max(ans0, tmp_ans)
''' Start at X[N-1] '''
''' In the case when turn first '''
ans1 = L-X[N-1]
i = 0
j = N-1
direc = -1 # direction: left->1, right->-1
while i!=j:
direc *= -1
ans1 += L+X[i]-X[j]
if direc==-1:
i += 1
elif direc==1:
j -= 1
if N%2==0:
i = (N-2)//2
j = (N-2)//2
else:
i = (N-2)//2
j = (N-2)//2+1
tmp_ans = ans1
for k in reversed(list(range(1, N))):
tmp_ans += -L+2*X[k]-X[i]-X[j]
if i==j:
i -= 1
else:
j -= 1
ans1 = max(ans1, tmp_ans)
print((max(ans0, ans1)))
#ans0 = X[0]
## 0, -1, 1, -2, ...
#i = 0
#j = N-1
#direc = 1 # direction: left->1, right->-1
#print('X[0]')
#while i!=j:
# print('L+X[%d]-X[%d]' % (i, j))
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
#ans0 = X[1]
#i = 1
#j = N-1
#direc = 1 # direction: left->1, right->-1
#print('X[1]')
#while i!=j:
# print('L+X[%d]-X[%d]' % (i, j))
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
#ans0 = X[2]
#i = 2
#j = N-1
#direc = 1 # direction: left->1, right->-1
#print('X[2]')
#while i!=j:
# print('L+X[%d]-X[%d]' % (i, j))
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
#ans0 = X[3]
#i = 3
#j = N-1
#direc = 1 # direction: left->1, right->-1
#print('X[3]')
#while i!=j:
# print('L+X[%d]-X[%d]' % (i, j))
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
#
#ans0 = X[4]
#i = 4
#j = N-1
#direc = 1 # direction: left->1, right->-1
#print('X[4]')
#while i!=j:
# print('L+X[%d]-X[%d]' % (i, j))
# direc *= -1
# ans0 += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
#print(ans0)
## 0, -1, 1, -2, 2, ...
## 0, 1, -1, 2, -2, 3, ...
''' N^2 case '''
#ans0 = 0
#for k in range(N):
# tmp_ans = X[k]
# i = k
# j = N-1
# direc = 1 # direction: left->1, right->-1
# while i!=j:
# direc *= -1
# tmp_ans += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
# if ans0<tmp_ans:
# ans0 = tmp_ans
#
#ans1 = 0
#for k in reversed(range(N)):
# tmp_ans = L-X[k]
# i = 0
# j = k
# direc = -1 # direction: left->1, right->-1
# print("L-X[%d]" % k)
# while i!=j:
# print("L+X[%d]-X[%d]" % (i, j))
# direc *= -1
# tmp_ans += L+X[i]-X[j]
# if direc==-1:
# i += 1
# elif direc==1:
# j -= 1
# if ans1<tmp_ans:
# ans1 = tmp_ans
# print('='*80)
#
#print(max(ans0, ans1))
| p03187 |
l,n,*ki=list(map(int,open(0).read().split()))
fmax=rmax=0
fl=[]
for ii in range(n):
f=0
x=ki[ii:]
lx=n-ii
for i in x[:(lx+1)//2]:
f+=i*2
for i in x[(lx+1)//2:]:
f+=(l-i)*2
if lx%2:
sa = x[lx//2]
else:
sa = l - x[lx // 2]
f-=sa
fl.append(f)
for ii in range(n):
r=0
x=ki[:n-ii]
lx=n-ii
for i in x[:lx//2]:
r += i * 2
for i in x[lx//2:]:
r+=(l-i)*2
if lx%2:
sa = l - x[(lx-1) // 2]
else:
sa = x[(lx-1)//2]
r-=sa
fl.append(r)
print((max(fl))) | ln, kn, *ki = list(map(int, open(0).read().split()))
# 順回転
pa = ki[-1]
ky = [pa]
kigu = 1
for ys in range(2, kn + 1):
# 要素数が偶数の場合
if kigu == 1:
pa += ki[kn - ys] * 2 + ln - ki[-(ys // 2)] * 2
# 要素数が奇数の場合
else:
pa += ki[kn - ys] * 2 - ki[-(ys // 2) - 1] + ln - ki[-(ys // 2)]
ky.append(pa)
kigu *= -1
# 逆回転
pa = ln - ki[0]
ky.append(pa)
kigu = 1
for ys in range(2, kn + 1):
# 要素数が偶数の場合
if kigu == 1:
pa += (ln-ki[ys - 1]) * 2 - ln + ki[ys // 2 - 1] * 2
# 要素数が奇数の場合
else:
pa += (ln-ki[ys - 1]) * 2+ki[ys//2]-ln+ki[ys//2-1]
ky.append(pa)
kigu *= -1
print((max(ky))) | p03187 |
from collections import deque
import math
L, N = list(map(int, input().split()))
XAntiClock, XClock = deque(), deque()
DistAntiClock, DistClock = deque(), deque()
DistAntiClock.append(0)
DistClock.append(0)
for i in range(N):
x = int(eval(input()))
XAntiClock.append(x)
XClock.appendleft(L-x)
DistAntiClock.append(DistAntiClock[-1] + 2 * x)
for i in range(N):
DistClock.append(DistClock[-1] + XClock[i] * 2)
maxLength = max(XAntiClock[N-1], XClock[N-1])
for i in range(1, N):
finIndex = math.ceil((i + N)/2)
if (i + N) % 2 == 0:
AntiClockLength = DistAntiClock[finIndex] - DistAntiClock[i-1] - XAntiClock[finIndex-1] + DistClock[N - finIndex]
ClockLength = DistClock[finIndex] - DistClock[i-1] - XClock[finIndex-1] + DistAntiClock[N - finIndex]
else:
AntiClockLength = DistAntiClock[finIndex - 1] - DistAntiClock[i-1] + DistClock[N - finIndex + 1] - XClock[N - finIndex]
ClockLength = DistClock[finIndex - 1] - DistClock[i-1] + DistAntiClock[N - finIndex + 1] - XAntiClock[N - finIndex]
maxLength = max(max(AntiClockLength, ClockLength), maxLength)
print(maxLength) | import math
L, N = list(map(int, input().split()))
X = [None for i in range(N)]
DistAntiClock, DistClock = [0 for i in range(N+1)], [0 for i in range(N+1)]
for i in range(N):
X[i] = int(eval(input()))
DistAntiClock[i+1] = DistAntiClock[i] + 2 * X[i]
for i in range(N):
DistClock[i+1] = DistClock[i] + (L - X[-1-i]) * 2
maxLength = max(X[N-1], L - X[0])
for i in range(1, N):
finIndex = math.ceil((i + N)/2)
if (i + N) % 2 == 0:
AntiClockLength = DistAntiClock[finIndex] - DistAntiClock[i-1] - X[finIndex-1] + DistClock[N - finIndex]
ClockLength = DistClock[finIndex] - DistClock[i-1] - (L-X[-finIndex]) + DistAntiClock[N - finIndex]
else:
AntiClockLength = DistAntiClock[finIndex - 1] - DistAntiClock[i-1] + DistClock[N - finIndex + 1] - (L - X[finIndex - 1])
ClockLength = DistClock[finIndex - 1] - DistClock[i-1] + DistAntiClock[N - finIndex + 1] - X[N - finIndex]
maxLength = max(max(AntiClockLength, ClockLength), maxLength)
print(maxLength) | p03187 |
import sys
input = sys.stdin.readline
L,N=list(map(int,input().split()))
X=[0]+[int(eval(input())) for i in range(N)]
def LENG(a,b,start):
if b==0:
if start>a:
return a
else:
return L-a
if a>b:
a,b=b,a
return a+L-b
#CANDI=[(N+1)//2,(N+1)//2-1,(N+1)//2+1]
#(i+2)//2*(-1)**i
ANS=0
for start in range(1,N+1):
if start==0:
continue
s=start
t=(s+(-1)**0)%(N+1)
ANS1=0
for i in range(2,N+3):
ANS1+=LENG(X[s],X[t],X[start])
#print(s,t,i,ANS1)
s,t=t,(t-i*((-1)**i))%(N+1)
if s==0:
break
#print(ANS1)
s=start
t=(s-(-1)**0)%(N+1)
ANS2=0
for i in range(2,N+3):
ANS2+=LENG(X[s],X[t],X[start])
#print(s,t,i,ANS2)
s,t=t,(t+i*((-1)**i))%(N+1)
if s==0:
break
#print(ANS2)
ANS=max(ANS,ANS1,ANS2)
print(ANS)
| import sys
input = sys.stdin.readline
L,N=list(map(int,input().split()))
X=[0]+[int(eval(input())) for i in range(N)]
S=[]
for i in range(N):
S.append(X[i+1]-X[i])
S.append(L-X[-1])
#print(S)
DIS=L-S[-1]
ANS=L-S[-1]
MINUS=0
PLUS=L-S[-1]
#print(DIS)
for i in range(N-1):
if i%2==0:
MINUS+=S[-i-2]
PLUS+=S[-i//2-1]-S[-i-2]
else:
MINUS+=S[-i-2]-S[-i-1+i//2]
PLUS-=S[-i-2]
DIS+=PLUS-MINUS
if ANS<DIS:
ANS=DIS
#print(DIS,PLUS,MINUS)
S=S[::-1]
DIS=L-S[-1]
MINUS=0
PLUS=L-S[-1]
#print(DIS)
for i in range(N-1):
if i%2==0:
MINUS+=S[-i-2]
PLUS+=S[-i//2-1]-S[-i-2]
else:
MINUS+=S[-i-2]-S[-i-1+i//2]
PLUS-=S[-i-2]
DIS+=PLUS-MINUS
if ANS<DIS:
ANS=DIS
#print(DIS,PLUS,MINUS)
print(ANS)
| p03187 |
def is_even(num):
return num % 2 == 0
def goback(M, x):
k = M // 2
if M == 0:
return L - x[0]
elif M == 1:
return 2 * (L - x[1]) + x[0]
elif is_even(M):
return 2 * sum(x[0:k]) - 2 * sum(x[M - k + 1:M + 1]) - x[M - k] + L * (2 * k + 1)
else:
return 2 * sum(x[0:k]) + x[k] - 2 * sum(x[M - k:M + 1]) + L * 2 * (k + 1)
L, N = (int(i) for i in input().split())
points = []
ans = []
for i in range(0, N):
points.append(int(eval(input())))
for i in range(0, N):
ans.append((goback(i, points)))
revpoints = [L - p for p in points[::-1]]
for i in range(0, N):
ans.append((goback(i, revpoints)))
print((max(ans))) | def is_even(num):
return num % 2 == 0
def goback(M, x, Sx):
k = M // 2
if M == 0:
return L - x[0]
elif M == 1:
return 2 * (L - x[1]) + x[0]
elif is_even(M):
return 2 * Sx[k - 1] - 2 * (Sx[M] - Sx[M - k]) - x[M - k] + L * (2 * k + 1)
else:
return 2 * Sx[k - 1] + x[k] - 2 * (Sx[M] - Sx[M - k - 1]) + L * 2 * (k + 1)
L, N = (int(i) for i in input().split())
ans = 0
pl = []
for i in range(N):
pl.append(int(eval(input())))
sumpl = [pl[0]]
for i in range(1, N):
sumpl.append(sumpl[i - 1] + pl[i])
for i in range(0, N):
ans = max(ans, goback(i, pl, sumpl))
revpl = [L - p for p in pl[::-1]]
sumrevpl = [revpl[0]]
for i in range(1, N):
sumrevpl.append(sumrevpl[i - 1] + revpl[i])
for i in range(0, N):
ans = max(ans, goback(i, revpl, sumrevpl))
print(ans) | p03187 |
import sys
def 解():
L,N=[int(_) for _ in input().split()]
aX=[int(_) for _ in sys.stdin.readlines()]
iMax = max(aX[0],L-aX[0],aX[-1],L-aX[-1])
if 1 < N:
for i in range(N-1):
lN = min(i,N-i-1)
rN = min(i+1,N-i-1)
R1 = aX[i]+ 2*sum(aX[i-lN:i]) + 2*(rN*L-(sum(aX[i+1:i+rN+1])))
i += 1
lN = min(i,N-i)
rN = min(i,N-i-1)
R2 = (L- aX[i])+ 2*sum(aX[i-lN:i]) + 2*(rN*L-(sum(aX[i+1:i+rN+1])))
iMax = max(R1,R2,iMax)
print(iMax)
解()
| import sys
def 解():
L,N=[int(_) for _ in input().split()]
aX=[int(_) for _ in sys.stdin.readlines()]
iMax = max(aX[0],L-aX[0],aX[-1],L-aX[-1])
accX = [0]*(N+1)
accX[0]=aX[0]
for i in range(1,N):
accX[i]=accX[i-1]+aX[i]
if 1 < N:
for i in range(N-1):
lN = min(i,N-i-1)
rN = min(i+1,N-i-1)
#R1 = aX[i]+ 2*sum(aX[i-lN:i]) + 2*(rN*L-(sum(aX[i+1:i+rN+1])))
R1 = aX[i]+ 2*(accX[i-1]-accX[i-lN-1]) + 2*(rN*L-(accX[i+rN]-accX[i]))
i += 1
lN = min(i,N-i)
rN = min(i,N-i-1)
#R2 = (L- aX[i])+ 2*sum(aX[i-lN:i]) + 2*(rN*L-(sum(aX[i+1:i+rN+1])))
R2 = (L- aX[i])+ 2*(accX[i-1]-accX[i-lN-1]) + 2*(rN*L-(accX[i+rN]-accX[i]))
iMax = max(R1,R2,iMax)
print(iMax)
解()
| p03187 |
n,m=list(map(int,input().split(' ')))
a=list(map(int,input().split(' ')))
asum=sum(a)
if(n-asum)<0:
print("-1")
exit()
else:
print((n-asum))
exit()
| n,m=list(map(int,input().split(' ')))
a=list(map(int,input().split(' ')))
asum=sum(a)
if(n-asum)<0:
print("-1")
else:
print((n-asum))
| p02706 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
s = sum(a)
print((max(-1,n-s))) | n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
#合計で何日かかるかを計算して
s = sum(a)
#遊べる日数はn-sで、n-s<0になったら宿題終わらないので-1を出す
print((max(-1,n-s)))
| p02706 |
import sys
input = sys.stdin.readline
from collections import *
from math import *
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
S = sum(A)
if S>N:
print((-1))
else:
print((N-S)) | import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
S = sum(A)
if S>N:
print((-1))
else:
print((N-S)) | p02706 |
n, m = [int(i) for i in input().split(' ')]
a_list = [int(i) for i in input().split(' ')]
result = n - sum(a_list)
if result < 0:
print((-1))
else:
print(result)
| n, m = list(map(int, input().split()))
a_list = list(map(int, input().split()))
result = n - sum(a_list)
if result < 0:
print((-1))
else:
print(result)
| p02706 |
import sys
from collections import deque
import copy
def main():
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
count = 0
for i in range(M):
count += A[i]
if N - count < 0:
print((-1))
else:
print((N - count))
if __name__ == '__main__':
main()
| import sys
from collections import deque
import copy
def main():
N, M = list(map(int, input().split()))
A = [int(i) for i in input().split()]
count = sum(A)
if N - count < 0:
print((-1))
else:
print((N - count))
if __name__ == '__main__':
main()
| p02706 |
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
if n < sum(a):
print((-1))
else:
print((n-sum(a)))
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
print((-1 if n < sum(a) else n - sum(a))) | p02706 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A_sum = sum(A)
ans = N - A_sum
if ans>=0:
print(ans)
else:
print((-1)) | N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A_sum = sum(A)
if N - A_sum>=0:
print((N - A_sum))
else:
print((-1))
| p02706 |
NM = list(map(int, input().split()))
a = list(map(int, input().split()))
x = 0
for i in range(NM[1]):
x += a[i]
if x > NM[0]:
print((-1))
else:
print((NM[0] - x)) | NM = list(map(int, input().split()))
N, M = NM[0],NM[1]
a = list(map(int, input().split()))
if sum(a)> N:
print((-1))
else:
print((N - sum(a))) | p02706 |
NM = list(map(int, input().split()))
N, M = NM[0],NM[1]
a = list(map(int, input().split()))
if sum(a)> N:
print((-1))
else:
print((N - sum(a))) | NM = list(map(int, input().split()))
N, M = NM[0],NM[1]
a = list(map(int, input().split()))
A = sum(a)
if A> N:
print((-1))
else:
print((N - A)) | p02706 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
d = n - sum(a)
print((d if d >= 0 else -1)) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
print((max(n - sum(a), -1))) | p02706 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
a = sum(A)
if a > N:
print((-1))
else:
print((N - a))
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
print((max(N - sum(A), -1)))
| p02706 |
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
print((n-sum(a) if n-sum(a)>=0 else -1)) | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
print((max(-1,n-sum(a)))) | p02706 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = n- sum(a)
if ans>=0:
print(ans)
else:
print((-1)) | N, M = list(map(int,input().split()))
A =list(map(int,input().split()))
print((max(-1,N-sum(A)))) | p02706 |
N, M = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
free = N - sum(l)
print((free if free>=0 else -1)) | N, M = list(map(int, input().split()))
l = list(map(int, input().split()))
free = N - sum(l)
print((free if free>=0 else -1)) | p02706 |
import math
N, M = map(int, input().split())
A = sum(map(int, input ().split()))
print(N - A) if N - A >= 0 else print(-1)
| N, M = map(int, input().split())
A = sum(map(int, input ().split()))
print(N - A) if N - A >= 0 else print(-1)
| p02706 |
n, m, *A = list(map(int, open(0).read().split()))
ans = n-sum(A)
print((ans if ans >= 0 else -1)) | n, m, *A = list(map(int, open(0).read().split()))
print((max(n-sum(A), -1))) | p02706 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(m):
n -= a[i]
if n < 0:
print((-1))
else:
print(n)
| n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
if n >= sum(a):
print((n-sum(a)))
else:
print((-1))
| p02706 |
# import sys
# sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def solve():
n, m = MI()
A = LI()
sm = sum(A)
if n - sm >= 0:
print((n - sm))
else:
print((-1))
if __name__ == '__main__':
solve()
| import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
INF = float('inf')
def solve():
n, m = MI()
A = LI()
s = sum(A)
print((max(n - s, -1)))
if __name__ == '__main__':
solve()
| p02706 |
N, M = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
sum_a = 0
for i in a:
sum_a += i
if sum_a > N:
print((-1))
else:
print((N - sum_a)) | def to_do():
N,M=list(map(int,input().split()))
day_list=list(map(int,input().split()))
sum=0
for i in range(0,M):
sum=sum+day_list[i]
if sum>N:
print((-1))
if sum<=N:
print((N-sum))
if __name__=="__main__":
to_do() | p02706 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(M):
N -= A[i]
if N>=0:
print(N)
elif N < 0:
print((-1)) | #先にAの合計値を出してもよい
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
suma = sum(A)
if N-suma>=0:
print((N-suma))
else:
print((-1)) | p02706 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
if sum(a)>n:
print('-1')
else:
print((n-sum(a)))
| n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
print(('-1' if sum(a)>n else n-sum(a))) | p02706 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
d = sum(A)
if N < d:
print((-1))
else:
print((N-d)) | N, M = list(map(int, input().split()))
As = list(map(int, input().split()))
d = sum(As)
if N < d:
print((-1))
else:
print((N-d))
| p02706 |
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = 0
for i in range(m):
b +=a[i]
if n<b:
print("-1")
else:
print((n-b)) | n,m = list(map(int,input().split()))
a = list(map(int, input().split()))
b = sum(a)
print((max(-1,n-b))) | p02706 |
n,m=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
rem = n-sum(a)
print((rem if rem>=0 else -1))
| n,m=list(map(int,input().split()))
for num in input().split():
n-=int(num)
print((n if n>=0 else -1))
| p02706 |
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
ans = N - sum(A)
print((ans if ans >= 0 else -1)) | N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
print((ans if (ans := N - sum(A)) >= 0 else -1)) | p02706 |
def getxy(P,x,y,ans):
for dy in range(m):
for dx in range(m):
if P[dy][dx] > -1:
xy = [x+dx+1,y+dy+1]
if ans == "NA" or xy[1] < ans[1] or (xy[1] == ans[1] and xy[0] < ans[0]):
return xy
else:
return ans
# try-except is necessary
while 1:
try:
n,m = list(map(int,input().split()))
if n == 0: break
S = [list(map(int,input().split())) for i in range(n)]
P = [list(map(int,input().split())) for i in range(m)]
ans = "NA"
for rot in range(4):
if S == P:
ans = getxy(P,0,0,ans)
for y in range(n-m+1):
for x in range(n-m+1):
flag = 0
for dy in range(m):
for dx in range(m):
if P[dy][dx] > -1 and S[y+dy][x+dx] - P[dy][dx] != 0:
flag = 1
break
if flag == 1: break
if flag == 0:
ans = getxy(P,x,y,ans)
break
if flag == 0: break
P = [[P[j][i] for j in range(m-1,-1,-1)] for i in range(m)]
print(ans if ans == "NA" else " ".join(map(str,ans)))
except:
pass | def getxy(P,x,y,ans):
for dy in range(m):
for dx in range(m):
if P[dy][dx] > -1:
xy = [x+dx+1,y+dy+1]
if xy[1] < ans[1] or (xy[1] == ans[1] and xy[0] < ans[0]):
return xy
else:
return ans
# try-except is necessary
while 1:
try:
n,m = list(map(int,input().split()))
if n == 0: break
S = [list(map(int,input().split())) for i in range(n)]
P = [list(map(int,input().split())) for i in range(m)]
ans = [n+1,n+1]
for rot in range(4):
for y in range(min(ans[1],n-m+1)):
for x in range(n-m+1):
flag = 0
for dy in range(m):
for dx in range(m):
if P[dy][dx] > -1 and S[y+dy][x+dx] - P[dy][dx] != 0:
flag = 1
break
if flag == 1: break
if flag == 0:
ans = getxy(P,x,y,ans)
break
if flag == 0: break
P = [[P[j][i] for j in range(m-1,-1,-1)] for i in range(m)]
print("NA" if ans == [n+1,n+1] else " ".join(map(str,ans)))
except:
pass | p00209 |
def main(piece, c):
for h in range(n-m+1):
for w in range(n-m+1):
if f(piece, h, w):
break
if c != 4:
move(piece, c)
else:
if ans:
print(ans[0], ans[1])
else:
print('NA')
def f(piece, h, w):
global ans
coordinate = None
for _h in range(m):
for _w in range(m):
if piece[_h][_w] != '-1':
if piece[_h][_w] == picture[h+_h][w+_w]:
if coordinate is None:
coordinate = (int(w+_w+1), int(h+_h+1))
if ans:
if coordinate[1] > ans[1]:
return
elif coordinate[1] == ans[1]:
if coordinate[0] > ans[0]:
return
else:
return
else:
ans = coordinate
return True
def move(piece, c):
_piece = []
for w in range(m):
lis = []
for h in range(m):
lis.append(piece[h][w])
else:
lis.reverse()
_piece.append(lis)
else:
main(_piece, c+1)
while True:
n, m = list(map(int, input().split()))
if n == m == 0: break
picture = [input().split() for i in range(n)]
piece = [input().split() for i in range(m)]
ans = None
main(piece, 1) | def main(piece, c):
for h in range(n-m+1):
for w in range(n-m+1):
if f(piece, h, w):
break
if c != 4:
move(piece, c)
else:
if ans:
print(ans[0], ans[1])
else:
print('NA')
def f(piece, h, w):
global ans
coordinate = None
for _h in range(m):
for _w in range(m):
if piece[_h][_w] != '-1':
if piece[_h][_w] == picture[h+_h][w+_w]:
if coordinate is None:
coordinate = (int(w+_w+1), int(h+_h+1))
else:
return
else:
if ans is None:
ans = coordinate
elif coordinate[1] < ans[1]:
ans = coordinate
elif coordinate[1] == ans[1]:
if coordinate[0] < ans[0]:
ans = coordinate
return True
def move(piece, c):
_piece = []
for w in range(m):
lis = []
for h in range(m):
lis.append(piece[h][w])
else:
lis.reverse()
_piece.append(lis)
else:
main(_piece, c+1)
while True:
n, m = list(map(int, input().split()))
if n == m == 0: break
picture = [input().split() for i in range(n)]
piece = [input().split() for i in range(m)]
ans = None
main(piece, 1) | p00209 |
from functools import lru_cache
import sys
iMaxStackSize = 5000000
sys.setrecursionlimit(iMaxStackSize)
n = int(eval(input()))
heights = [int(x) for x in input().split()]
@lru_cache(None)
def solve(i):
if i == n - 1:
return 0
if i + 2 >= len(heights):
return abs(heights[i + 1] - heights[i])
option1 = abs(heights[i] - heights[i + 1])
option1 += solve(i + 1)
option2 = abs(heights[i] - heights[i + 2])
option2 += solve(i + 2)
return min(option1, option2)
print((solve(0)))
| n = int(eval(input()))
heights = [int(x) for x in input().split()]
dp = [float("inf")] * n
dp[0] = 0
for i in range(1, n):
if i - 2 >= 0:
val1 = abs(heights[i] - heights[i - 1]) + dp[i - 1]
val2 = abs(heights[i] - heights[i - 2]) + dp[i - 2]
dp[i] = min(val1, val2)
else:
dp[i] = abs(heights[i] - heights[i - 1]) + dp[i - 1]
print((dp[-1])) | p03160 |
n=int(eval(input()))
A=list(map(int,input().split()))
inf=float("inf")
dp=[inf for i in range(n)]
dp[0]=0
dp[1]=abs(A[1]-A[0])
for i in range(2,n):
dp[i]=min(dp[i],abs(A[i-1]-A[i])+dp[i-1],abs(A[i-2]-A[i])+dp[i-2])
print((dp[n-1])) | n=int(eval(input()))
A=list(map(int,input().split()))
#dp[i]:=iにつくまでの最小コスト
dp=[1145141919810 for i in range(n)]
dp[0]=0
dp[1]=abs(A[0]-A[1])
for i in range(2,n):
dp[i]=min(dp[i-2]+abs(A[i-2]-A[i]),dp[i-1]+abs(A[i-1]-A[i]))
print((dp[n-1])) | p03160 |
N = int(eval(input()))
High = list(map(int, input().split()))
DP = [0]*N
DP[1] = abs(High[0]-High[1])
for i in range(2, N):
DP[i] = min(DP[i-2] + abs(High[i] - High[i - 2]), DP[i-1] + abs(High[i] - High[i - 1]))
print((DP[N-1])) | N = int(eval(input()))
H = [float('inf')] + list(map(int, input().split()))
DP = [0] * (N+1)
for i in range(2, N+1):
DP[i] = min(abs(H[i] - H[i-1]) + DP[i-1], abs(H[i] - H[i-2]) + DP[i-2])
print((DP[N]))
| p03160 |
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('Inf')] * n
dp[0] = 0
for i in range(1, n):
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]))
if i > 1:
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n - 1])) | n = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('Inf')] * n
dp[0] = 0
for i in range(n - 1):
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]))
if i + 2 < n:
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]))
print((dp[n - 1])) | p03160 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.