input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from collections import defaultdict
def inpl():
return list(map(int, input().split()))
N, K = inpl()
aa = inpl()
s = 1
route = [s]
ed = set([s])
for i in range(1, K + 1):
s = aa[s - 1]
if s in ed:
Li = route.index(s)
Ri = len(route)
idx = Li + (K - Li) % (Ri - Li)
print((route[idx]))
break
else:
route.append(s)
ed.add(s)
continue
else:
print(s)
| N, K = list(map(int, input().split()))
al = list(map(int, input().split()))
visited= [1]
ed = set([1])
for i in range(K):
next_town = al[visited[i] - 1]
if next_town in ed:
loop_sta = visited.index((next_town)) # visited_townsにおけるループ開始のインデックス
loop_end = len(visited) #visited_townsにおけるループの終わりのインデックス
loop_length = loop_end - loop_sta #繰り返すループの長さ
amari = (K - loop_sta) % loop_length
ans = visited[loop_sta + amari]
print(ans)
exit()
else:
visited.append(next_town)
ed.add(next_town)
continue
else:
print((visited[-1]))
| p02684 |
from sys import stdin
def main():
n, k = list(map(int, stdin.readline().rstrip().split()))
a = [int(x)-1 for x in stdin.readline().rstrip().split()]
n = a[0]
his = [-1, n]
f = his.append
while True:
n = a[n]
if n in his:
f(n)
break
f(n)
idx = his.index(his[-1])
loop = len(his[his.index(his[-1]):-1])
if len(his) > k:
print((his[k]+1))
else:
t = (k - idx) % loop
g = his[idx:-1]
print((g[t]+1))
main() | from sys import stdin
def main():
n, k = list(map(int, stdin.readline().rstrip().split()))
a = [int(x)-1 for x in stdin.readline().rstrip().split()]
n = a[0]
his = [-1, n]
f = his.append
s = set()
while True:
n = a[n]
if n in s:
f(n)
break
f(n)
s.add(n)
idx = his.index(his[-1])
loop = len(his[his.index(his[-1]):-1])
if len(his) > k:
print((his[k]+1))
else:
t = (k - idx) % loop
g = his[idx:-1]
print((g[t]+1))
main() | p02684 |
N,K = [int(i) for i in input().split(' ')]
A = [int(i) for i in input().split(' ')]
where_li = []
pre = 0
for i in range(N):
where_li.append(A[pre])
pre = A[pre]-1
aa = sorted([x for x in set(where_li) if where_li.count(x) > 1], key=where_li.index)
if(len(aa)==0):
indexes = [0,0]
else:
indexes = [i for i, x in enumerate(where_li) if x == aa[0]]
where_li = where_li[:indexes[1]]
len_w = len(where_li)
mod_s = len_w-indexes[0]
if K<=len_w:
print((where_li[K-1]))
else:
if (K-len_w)%mod_s==0:
d = mod_s
else:
d = (K-len_w)%mod_s
print((where_li[d-1+indexes[0]])) | N,K = [int(i) for i in input().split(' ')]
A = [int(i) for i in input().split(' ')]
where_li = []
pre = 0
for i in range(N):
where_li.append(A[pre])
pre = A[pre]-1
len_w = len(where_li)
a = where_li.index(A[pre])
mod_s = len_w-a
if K<=len_w:
print((where_li[K-1]))
else:
if (K-len_w)%mod_s==0:
d = mod_s
else:
d = (K-len_w)%mod_s
print((where_li[d-1+a])) | p02684 |
import sys
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
alr = []
now = 1
i = 0
while not now in alr:
alr.append(now)
now = A[now-1]
i += 1
if i == K:
print(now)
sys.exit()
place = alr.index(now)
circle = len(alr) - place
rem = (K - place) % circle
print((alr[place + rem])) | import sys
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
alr = {}
now = 1
i = 0
while not now in list(alr.keys()):
alr[now] = i
now = A[now-1]
i += 1
if i == K:
print(now)
sys.exit()
place = alr[now]
circle = len(alr) - place
rem = (K - place) % circle
for k, v in list(alr.items()):
if v == place + rem:
print(k)
break | p02684 |
a = input().split(" ")
N = eval(a[0])
K = eval(a[1])
dic = {}
b = input().split(" ")
for i in range(1, N + 1):
dic[i] = eval(b[i - 1])
ans = 1
lst = []
length = 0
while K > 0:
if ans in lst:
left = lst.index(ans)
right = length
zq = right - left
K = K % zq
if K == 0:
break
else:
lst.append(ans)
length += 1
ans = dic[ans]
K -= 1
print(ans) | a = input().split(" ")
N = eval(a[0])
K = eval(a[1])
dic = {}
b = input().split(" ")
n_lst = [-1]
for i in range(1, N + 1):
dic[i] = eval(b[i - 1])
n_lst.append(-1)
ans = 1
lst = []
length = 0
while K > 0:
if n_lst[ans] != -1:
left = n_lst[ans]
zq = length - left
K = K % zq
if K == 0:
break
else:
n_lst[ans] = length
length += 1
ans = dic[ans]
K -= 1
print(ans) | p02684 |
def main():
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
visited = [0]
now = 0
ind = 0
my_append = visited.append
for _ in range(K):
a = A[now]-1
if a in visited:
ind = visited.index(a)
break
else:
my_append(a)
now = a
loop_visited = visited[ind:]
ans_ind = (K-ind) % len(loop_visited)
print((loop_visited[ans_ind]+1))
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# N = 2*(10**4)
# K = 10**18
# A = [i+2 for i in range(N)]
# A[-1] = 1
# print(A)
visited = [0]
visited_set = set([0])
now = 0
ind = 0
my_append = visited.append
my_add = visited_set.add
for i in range(K):
a = A[now]-1
if a in visited_set:
ind = visited.index(a)
break
else:
my_add(a)
my_append(a)
now = a
# ind = i
loop_visited = visited[ind:]
ans_ind = (K-ind) % len(loop_visited)
print((loop_visited[ans_ind]+1))
if __name__ == "__main__":
main()
| p02684 |
from collections import deque
import sys
def main():
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = [int(x) for x in input().split()]
#ループを探す？
checked_list = [1]
que = deque([a[0]])
counter = 0
q_append = que.append
c_append = checked_list.append
while True:
counter += 1
x = que.popleft()
if counter == k:
print(x)
exit()
if x in set(checked_list):
startflg = checked_list.index(x)
loop_length = counter - startflg
loop_list = checked_list[startflg:counter]
amari = (k-startflg) % loop_length
print((loop_list[amari]))
exit()
else:
q_append(a[x-1])
c_append(x)
if __name__ == '__main__':
main() | from collections import deque
import sys
def main():
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = [int(x) for x in input().split()]
#ループを探す？
checked_dict = {1:0}
que = deque([a[0]])
counter = 0
while True:
counter += 1
x = que.popleft()
if counter == k:
print(x)
exit()
if x in checked_dict:
startflg = checked_dict[x]
loop_length = counter - startflg
inverse_dict = {v:k for k,v in list(checked_dict.items())}
loop_list = [inverse_dict[i] for i in range(startflg,startflg+loop_length)]
amari = (k-startflg) % loop_length
print((loop_list[amari]))
exit()
else:
que.append(a[x-1])
checked_dict[x] = counter
if __name__ == '__main__':
main() | p02684 |
n,k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
r = [1]
k += 1
now = 1
for i in range(n):
now = a[now]
if now in r: break
r.append(now)
if len(r) == k:
print(now)
exit()
I = r.index(now)
if I != 0:
k -= I
r = r[I:]
print((r[-1] if k%len(r)==0 else r[k%len(r)-1])) | n,k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
now = 1
check = [-1]*(n+1)
for i in range(k):
if check[now] == -1:
check[now] = i
now = a[now]
else:
loop = i - check[now]
afterloop = (k-(i-loop))%loop
print((check.index((i-loop) + afterloop)))
exit()
print(now) | p02684 |
import sys
n,k = list(map(int,input().split()))
ls = list(map(int,input().split()))
def sub(k,s):
return k-s
p = [1]
i = 0
a = 0
t = 0
ans1 = 0
ans2 = 0
e = 3
while i<k-1:
if i ==0:
a = ls[i]
p.append(a)
if len(p) != len(list(set(p))):
q = [p[-1]]*(len(p))
p.pop()
new = list(map(sub,p,q))
t = new.index(0)
ans1 = len(p[:t])
ans2 = len(p[t:])
print((p[((k+1-ans1)%ans2)-1]))
sys.exit()
b = ls[a-1]
p.append(b)
if len(p) != len(list(set(p))):
q = [p[-1]]*(len(p))
p.pop()
new = list(map(sub,p,q))
t = new.index(0)
ans1 = len(p[:t])
ans2 = len(p[t:])
print((p[((k+1-ans1)%ans2)-1]))
sys.exit()
i += 1
else:
a = b
b = ls[a-1]
p.append(b)
e += 1
f = len(list(set(p)))
if e != f:
q = [p[-1]]*(e)
p.pop()
new = list(map(sub,p,q))
t = new.index(0)
ans1 = len(p[:t])
ans2 = e-1 - ans1
ansl = p[t:]
print((ansl[((k+1-ans1)%ans2)-1]))
sys.exit()
i += 1
print(b)
| n,k = list(map(int,input().split()))
ls = list(map(int,input().split()))
fi = [-1]*(n+1)
fi[1] = 0
a = 0
aa = 0
for i in range(k):
if fi[ls[a]] == -1:
fi[ls[a]] = i + 1
aa = a
a = ls[a] - 1
else:
ind = fi[ls[a]]
t = (k - ind) % (max(fi) + 1 - ind)
t += ind
print((fi.index(t)))
break
else:
print((ls[aa])) | p02684 |
n, k = [int(x) for x in input().strip().split()]
a = [int(x) for x in input().strip().split()]
assert len(a) == n
a = [0] + a
current = 1
way = [1]
for i in range(k):
current = a[current]
if current in way:
li = way.index(current)
loop = way[li:]
print((loop[(k - li) % len(loop)]))
break
else:
way.append(current)
else:
print(current)
| n, k = [int(x) for x in input().split()]
a = [int(x)-1 for x in input().split()]
assert len(a) == n
current = 0
visited = [-1] * n
visited[0] = 0
for i in range(1, k):
current = a[current]
if visited[current] == -1:
visited[current] = i
else:
pre = visited[current]
count = (k - pre) % (i - pre) + pre
print((visited.index(count)+1))
break
else:
print((a[current]+1))
| p02684 |
N,K = list(map(int,input().split()))
A = [0] + [int(i) for i in input().split()]
route = [1]
start = 1
cnt = 0
while True:
if cnt == K:
print((route[-1]))
exit()
elif A[start] in route:
index = route.index(A[start])
loop = len(route) - index
break
else:
route.append(A[start])
start = A[start]
cnt += 1
K -= index
K = K % loop
print((route[index:][K])) | N,K = list(map(int,input().split()))
A = [0] + [int(i) for i in input().split()]
route = [1]
route_set = set()
start = 1
cnt = 0
while True:
if cnt == K:
print((route[-1]))
exit()
elif A[start] in route_set:
index = route.index(A[start])
loop = len(route) - index
break
else:
route.append(A[start])
route_set.add(A[start])
start = A[start]
cnt += 1
K -= index
K = K % loop
print((route[index:][K])) | p02684 |
N, K = list(map(int, input().split()))
A = input().split()
A = [int(a) for a in A]
S = []
a = 1
number = 0
for _ in range(N + 1):
b = A[a - 1]
if b in S:
c = S.index(b)
break
number += 1
S.append(b)
a = b
T = S[c:number]
if K <= N:
print((S[K - 1]))
else:
z = K - c - 1
y = z % (number - c)
print((T[y]))
| N, K = list(map(int, input().split()))
A = input().split()
A = [int(a) for a in A]
S = [1]
a = 1
number = 0
numbers=[-1 for _ in range(N)]
for _ in range(N + 1):
b = A[a - 1]
if numbers[b-1] != -1:
c=numbers[b-1]
break
numbers[b-1]=number
number += 1
S.append(b)
a = b
T = S[c+1:number+1]
if K <= number:
print((S[K ]))
else:
z = K - c-1
y = z % (number - c)
print((T[y]))
| p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
g = dict()
for i, v in enumerate(a):
g[i+1] = v
def find_num(target):
path = 1
target_ = g[target]
while target_ != target:
target_ = g[target_]
path += 1
return path
target = 1
visited = []
flag = False
for i in range(k):
target = g[target]
if target not in visited:
visited.append(target)
else:
p = find_num(target)
flag = True
break
if flag:
for _ in range((k-1-i)%p):
target = g[target]
print(target)
else:
print(target) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
g = dict()
for i, v in enumerate(a):
g[i+1] = v
def find_num(target):
path = 1
target_ = g[target]
while target_ != target:
target_ = g[target_]
path += 1
return path
target = 1
visited = dict()
flag = False
for i in range(k):
target = g[target]
if target not in visited:
visited[target] = True
else:
p = find_num(target)
flag = True
break
if flag:
for _ in range((k-1-i)%p):
target = g[target]
print(target)
else:
print(target) | p02684 |
n, k = list(map(int, input().split()))
tele = list(map(int, input().split()))
loc = 1
act = [[0]*n for i in range(n)]
count = 1
log = []
log.append(loc)
while True:
newloc=tele[loc-1]
log.append(newloc)
#print(newloc)
if act[loc-1][newloc-1] == 0:
act[loc-1][newloc-1] =count
act[newloc-1][loc-1] =count
else:
loop=count-act[loc-1][newloc-1]
loopstart=act[loc-1][newloc-1]
break
count+=1
loc=newloc
if k <= loopstart:
ans=log[k]
else:
num = (k-(loopstart-1)) % loop
ans=log[loopstart-1+num]
#print(loop)
#print(loopstart)
#print(count)
#print(act)
#print(log)
print(ans)
| n, k = list(map(int, input().split()))
tele = list(map(int, input().split()))
loc = 1
act = [-1]*n
act[0]=0
count = 1
log = []
log.append(loc)
flg = True
while True:
newloc=tele[loc-1]
if count ==k:
print(newloc)
flg = False
log.append(newloc)
#print(newloc)
if act[newloc-1] == -1:
act[newloc-1] =count
else:
loop=count-act[newloc-1]
loopstart=act[newloc-1]
break
count+=1
loc=newloc
if flg:
num = (k-loopstart) % loop
ans=log[loopstart+num]
print(ans)
#print(loopstart)
#print(log)
#print(log[loopstart])
#print(num)
| p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
l = [1]
for i in range(n):
if a[l[i] - 1] in l:
res = l[:l.index(a[l[i] - 1])]
cyc = l[l.index(a[l[i] - 1]):]
break
else:
l += [a[l[i] - 1]]
print((cyc[(k - len(res)) % len(cyc)] if k > len(res) - 1 else res[k])) | n, k = list(map(int, input().split()))
a = list([int(x) - 1 for x in input().split()])
visited = [-1 for _ in range(n)]
visited[0] = 0
l = [0]
for i in range(k):
nex = a[l[i]]
if visited[nex] != -1:
res = visited[nex]
cyc = i + 1 - visited[nex]
break
else:
l += [nex]
visited[nex] = i + 1
else:
res = k + 1
print((l[res + (k - res) % cyc] + 1 if k > res else l[k] + 1))
| p02684 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, K = MAP()
A = LIST()
a = [1]
r = -1
loc = 1
for i in range(N):
loc = A[loc-1]
#print(loc)
if not loc in a:
a.append(loc)
#print(a)
else:
r = i+1
loop_start = loc
break
#print(a)
#print(r)
#print(loop_start)
for i in range(N):
if a[i] == loop_start:
l = i
break
first = a[:l]
loop = a[l:]
#print(l, r)
#print(first)
#print(loop)
K += 1
if K <= len(first):
print((a[K-1]))
else:
K -= len(first)
K %= len(loop)
print((loop[K-1])) | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, K = MAP()
A = LIST()
a = [1]
r = -1
loc = 1
b = [0]*(N+1)
b[1] = 1
for i in range(N):
loc = A[loc-1]
#print(loc)
if b[loc] == 0:
a.append(loc)
b[loc] = 1
#print(a)
else:
r = i+1
loop_start = loc
break
#print(a)
#print(r)
#print(loop_start)
for i in range(N):
if a[i] == loop_start:
l = i
break
first = a[:l]
loop = a[l:]
#print(l, r)
#print(first)
#print(loop)
K += 1
if K <= len(first):
print((a[K-1]))
else:
K -= len(first)
K %= len(loop)
print((loop[K-1]))
| p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = {}
for i in range(1, n + 1):
d[i] = a[i - 1]
did = set()
route = [1]
now = 1
for i in range(k):
now = d[now]
route.append(now)
if now in did:
break
did.add(now)
if k < 10 ** 6:#計算量的に間に合うので愚直に
now = 1
for i in range(k):
now = d[now]
print(now)
else:
for i in range(len(route)):
if route[i] == route[-1]:#routeには第二ループの始めがギリ入っている
roop = route[i:-1]
print((roop[(k - i) % len(roop)]))#k-iは残り移動階数
exit() | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
d = {}
for i in range(1, n + 1):
d[i] = a[i - 1]
did = set([1])
route = [1]
now = 1
for i in range(k):
now = d[now]
route.append(now)
if now in did:
break
did.add(now)
if k < 10 ** 6:#計算量的に間に合うので愚直に
now = 1
for i in range(k):
now = d[now]
print(now)
else:
for i in range(len(route)):
if route[i] == route[-1]:
roop = route[i:-1]
print((roop[(k - i) % len(roop)]))
exit()
| p02684 |
import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
cnt= 0
i = 1
cycle = ['1']
for c in range(n):
i = a[i-1]
if(i in cycle):
break
else:
cycle.append(i)
ind = cycle.index(i)
k-= ind
rcycle = cycle[ind:]
if(k <= 0):
print((cycle[k+ind]))
else:
now = (k+1)%len(rcycle)
print((rcycle[now-1])) | import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
'''
n, k = map(int, input().split())
a = list(map(int, input().split()))
cnt= 0
i = 1
cycle = ['1']
for c in range(n):
i = a[i-1]
if(i in cycle):
break
else:
cycle.append(i)
ind = cycle.index(i)
k-= ind
rcycle = cycle[ind:]
if(k <= 0):
print(cycle[k+ind])
else:
now = (k+1)%len(rcycle)
print(rcycle[now-1])
'''
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
already = ["1"]
set = {"1"}
now = 1
for i in range(n):
now = str(a[int(now)-1])
if now in set:
break
else:
already.append(now)
set.add(now)
ind = already.index(now)
k -= ind
cycle = already[ind:]
if k <= 0:
print((already[k+ind]))
else:
now = (k+1) % len(cycle)
print((cycle[now-1])) | p02684 |
n,k= list(map(int, input().split()))
li= list(map(int, input().split()))
c=[1]
nex=1
first=0
flag=0
for i in range(k):
nex=li[nex-1]
if nex in c:
first=c.index(nex)
flag=1
break
c.append(nex)
if flag:
k-=first
k%=len(c)-first
print((c[first+k]))
else:
print((c[-1])) | n,k= list(map(int, input().split()))
li= list(map(int, input().split()))
d = [0 for i in range(n)]
c=[1]
nex=1
first=0
flag=0
for i in range(k):
nex=li[nex-1]
if d[nex-1]:
first=c.index(nex)
flag=1
break
d[nex-1]=1
c.append(nex)
if flag:
k-=first
k%=len(c)-first
print((c[first+k]))
else:
print((c[-1])) | p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [0] + a
c = [1]
while c.count(c[-1]) == 1:
c.append(a[c[-1]])
t = c.index(c[-1])
if k <= t:
ans = c[k]
else:
ans = c[t + ((k-t) % (len(c)-1-t))]
print(ans) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [0] + a
c = [1]
x = True
y = [1, 1] + [0]*(n-1)
while x:
c.append(a[c[-1]])
y[c[-1]] += 1
if y[c[-1]] == 2:
x = False
t = c.index(c[-1])
if k <= t:
ans = c[k]
else:
ans = c[t + ((k-t) % (len(c)-1-t))]
print(ans) | p02684 |
from collections import deque
N, K= list(map(int, input().split()))
A = list(map(int, input().split()))
x = deque([1])
point = 1
count = 0
while True:
next_point = A[point-1]
if next_point in x :
x.append(next_point)
break
x.append(next_point)
point = next_point
f = x.index(next_point)
if K <=f:
print((x[K]))
else :
num = len(x) - f -1
x = list(x)[f+1:]
dic = {(n+1+f) %(num): i for n, i in enumerate(x)}
print((dic[K%num]))
| N, K= list(map(int, input().split()))
A = list(map(int, input().split()))
x = {1:0}
point = 1
count = 0
while True:
next_point = A[point-1]
count +=1
if next_point in x :
flag=next_point
break
x[next_point] =count
point = next_point
#print(count, x[flag])
c = count - x[flag]
f = x[flag]
#print(c)
if K <f:
print(([i for i in x if x[i] == K ][0]))
else :
dic = {j-f: i for i,j in list(x.items())}
print((dic[(K-f) % c])) | p02684 |
N, K = list(map(int,input().split()))
move_list = list(map(int,input().split()))
test = 1
find_f = {}
for i in range(N):
find_f[i+1]=[]
find_f[1].append(0)
for i in range(K):
test = move_list[test-1]
find_f[test].append(i+1)
if len(find_f[test]) == 2 and find_f[test][1]-find_f[test][0]<=100000:
state ,f = test, find_f[test]
break
try:
K = K-f[0]
f = f[1]-f[0]
remain = K%f
for i in range(remain):
state = move_list[state-1]
print(state)
except:
print(test)
#state = 1 | N, K = list(map(int,input().split()))
move_list = list(map(int,input().split()))
test = 1
find_f = {}
for i in range(N):
find_f[i+1]=[]
find_f[1].append(0)
for i in range(K):
test = move_list[test-1]
find_f[test].append(i+1)
if len(find_f[test]) == 2 and find_f[test][1]-find_f[test][0]<=1000000:
state ,f = test, find_f[test]
break
try:
K = K-f[0]
f = f[1]-f[0]
remain = K%f
for i in range(remain):
state = move_list[state-1]
print(state)
except:
print(test)
#state = 1 | p02684 |
n,k=[int(x) for x in input().split()]
p=[(int(x)-1) for x in input().split()]
a=[0]
i=0
while p[i] not in a:
a.append(p[i])
i=p[i]
l=a.index(p[i])
if k<=l: print((1+a[k]))
else: print((1+a[l+(k-l)%(len(a)-l)])) | n,k=[int(x) for x in input().split()]
p=[(int(x)-1) for x in input().split()]
alp=[0 for _ in range(n)]
a=[0]
i=0
alp[0]=1
while alp[p[i]]==0:
a.append(p[i])
alp[p[i]]=1
i=p[i]
l=a.index(p[i])
if k<=l: print((1+a[k]))
else: print((1+a[l+(k-l)%(len(a)-l)])) | p02684 |
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
init = [1]
len_loop = -1
while len(init) <= k:
nxt = a[init[-1]-1]
if nxt in init:
idx_nxt = init.index(nxt)
len_init = idx_nxt
len_loop = len(init) - idx_nxt
break
else:
init.append(nxt)
if len_loop == -1:
print((init[k]))
else:
idx = (k-len_init)%len_loop
print((init[len_init+idx])) | n, k = list(map(int, input().split()))
a = tuple([int(n) - 1 for n in input().split()])
visited = [0] * n
next_town = 0
order = []
while True:
if visited[next_town]:
break
order.append(next_town)
visited[next_town] = 1
next_town = a[next_town]
first_loop = len(order)
offset = order.index(next_town)
second_loop = first_loop - offset
if k < first_loop:
print((order[k] + 1))
else:
print((order[offset + (k - first_loop) % second_loop] + 1))
| p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] -= 1
mod = -1
num = [0]
prev = 0
cnt = 0
# num.append(0)
while True:
# print(num, cnt)
if not a[prev] in num:
num.append(a[prev])
prev = a[prev]
else:
lpst = a[prev]
mod = cnt - num.index(a[prev]) + 1
break
cnt += 1
# print(mod, lpst)
now = 0
while k > 0:
if now == lpst:
k %= mod
if k == 0:
break
now = a[now]
k -= 1
# print(now, k)
print((now+1)) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] -= 1
used = set()
num = [0]*n
used.add(0)
now = 0
cnt = 0
while True:
cnt += 1
if not a[now] in used:
used.add(a[now])
num[a[now]] = cnt
now = a[now]
else:
lps = a[now]
mod = cnt - num[a[now]]
# k %= mod
break
now = 0
# print(mod, lps, k, num)
while k:
if now == lps:
k %= mod
if k == 0:
break
now = a[now]
k -= 1
print((now+1)) | p02684 |
def main():
N, K = (int(i) for i in input().split())
A = [int(i) for i in input().split()]
d = []
d_set = set()
s = 1
for _ in range(N):
if s in d_set:
if K < len(d):
return print(d[K])
idx = d.index(s)
K -= idx
d = d[idx:]
break
d.append(s)
d_set.add(s)
s = A[s-1]
# print(idx, d)
K %= len(d)
print(d[K])
if __name__ == '__main__':
main()
| def main():
N, K = (int(i) for i in input().split())
A = [int(i) for i in input().split()]
d = [-1]*(N+1)
v = 1
i = 0
while d[v] == -1:
d[v] = i
v = A[v-1]
i += 1
c_length = i - d[v] # 閉路長
pre_c_length = d[v]
if K < i:
return print(d.index(K))
else:
K -= pre_c_length
K %= c_length
return print(d.index(pre_c_length+K))
if __name__ == '__main__':
main()
| p02684 |
N, K = list(map(int, input().split()))
A = [int(i)-1 for i in input().split()]
visited_town = []
current_town = 0
loop_flg = False
visited_town.append(current_town)
for i in range(K):
current_town = A[current_town]
if current_town in visited_town:
visited_town.append(current_town)
loop_flg = True
break
visited_town.append(current_town)
if loop_flg:
loop_start = visited_town.index(current_town)
loop_end = len(visited_town) - 1
loop_length = loop_end - loop_start
last_index = (K-loop_start)%loop_length
current_town = visited_town[loop_start+last_index]
print((current_town+1)) | def main():
N, K = list(map(int, input().split()))
A = [int(i)-1 for i in input().split()]
visited_town = []
current_town = 0
loop_flg = False
visited_town.append(current_town)
set_visted_town = set(visited_town)
for i in range(K):
current_town = A[current_town]
if current_town in set_visted_town:
visited_town.append(current_town)
loop_flg = True
break
visited_town.append(current_town)
set_visted_town.add(current_town)
if loop_flg:
loop_start = visited_town.index(current_town)
loop_end = len(visited_town) - 1
loop_length = loop_end - loop_start
last_index = (K-loop_start)%loop_length
current_town = visited_town[loop_start+last_index]
print((current_town+1))
if __name__ == '__main__':
main() | p02684 |
N, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
A = [a-1 for a in A]
# Douling(ダブリング)
i = 1
to = [[a for a in A]]
while pow(2, i) < K:
t = [to[i-1][to[i-1][j]] for j in range(N)]
to.append(t)
i += 1
i -= 1
ans = [i for i in range(N)]
while i >= 0:
if K & (1 << i) > 0:
for j in range(N):
ans[j] = to[i][ans[j]]
i -= 1
print((ans[0]+1)) | N, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
A = [a-1 for a in A]
# Douling(ダブリング)
i = 1
to = [[a for a in A]]
while pow(2, i) < K:
t = [to[i-1][to[i-1][j]] for j in range(N)]
to.append(t)
i += 1
i -= 1
ans = 0
while i >= 0:
if K & (1 << i) > 0:
ans = to[i][ans]
i -= 1
print((ans+1)) | p02684 |
from copy import copy
n, k = list(map(int, input().split()))
a = [int(i) - 1 for i in input().split()]
ans = 0
while k:
if k & 1:
ans = a[ans]
c = [a[a[i]] for i in range(n)]
a = copy(c)
k >>= 1
print((ans + 1)) | n, k = list(map(int, input().split()))
a = [int(i) - 1 for i in input().split()]
ans = 0
while k:
if k & 1:
ans = a[ans]
c = [a[a[i]] for i in range(n)]
a = c[:]
k >>= 1
print((ans + 1)) | p02684 |
n, k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
s = []
ord = [-1] * (n+1)
c, l = 1, 0
v = 1
while (ord[v] == -1):
ord[v] = len(s)
s.append(v)
v = a[v-1]
c = len(s) - ord[v]
l = ord[v]
print((s[k] if (k < l) else s[l + (k - l) % c])) | n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
ord = [-1] * (n + 1)
s = []
v = 1
c, l = 1, 0
while ord[v] == -1:
ord[v] = len(s)
s.append(v)
v = a[v - 1]
c = len(s) - ord[v]
l = ord[v]
print((s[k] if k < l else s[l + (k - l) % c])) | p02684 |
import sys
n,k=list(map(int,input().split()))
A=[int(i) for i in input().split()]
d=dict()
for i,a in enumerate(A):
d[i+1] = a
p=1
li = [1]
for i in range(k):
#print(p,li)
p = d[p]
if p in li:
pidx = li.index(p)
cyc = i+1-pidx
print((li[(k-pidx)%cyc+li.index(p)]))
sys.exit()
li.append(p)
else:
print(p) | import sys
n,k=list(map(int,input().split()))
A=[int(i) for i in input().split()]
d=dict()
for i,a in enumerate(A):
d[i+1] = a
p=1
li = set()
li.add(1)
for i in range(k):
#print(p,li)
p = d[p]
#print(p,li)
if p in li:
cyc = i + 1
q = 1
st=0
while q != p:
q = d[q]
st+=1
cyc -=st
k = (k-st) % cyc + st
r = 1
#print(k)
for _ in range(k):
#print(r)
r = d[r]
print(r)
sys.exit()
li.add(p)
else:
print(p) | p02684 |
from collections import deque
n, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
loop = deque([])
visited = set()
stack = deque([1])
loop_creating = False
last = 1
while True:
if loop_creating and len(visited) == 0:
break
nex = a[last - 1]
if nex in visited:
visited.remove(nex)
loop.append(nex)
loop_creating = True
elif nex in stack:
visited.add(nex)
else:
stack.append(nex)
last = nex
if k <= len(stack):
print((stack[k]))
elif k > len(stack):
rem = k - len(stack)
print((loop[rem % len(loop)]))
| from collections import deque
n, k = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
loop = []
visited = set()
s = set([1])
loop_creating = False
last = 1
while True:
if loop_creating and len(visited) == 0:
break
if k == len(s) - 1:
print(last)
exit(0)
nex = a[last - 1]
if nex in visited:
visited.remove(nex)
loop.append(nex)
loop_creating = True
elif nex in s:
visited.add(nex)
else:
s.add(nex)
last = nex
rem = k - len(s)
print((loop[rem % len(loop)]))
| p02684 |
import sys
from io import StringIO
import unittest
def resolve():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
loop_list = []
now = 0
if k > n:
while 1:
now = a[now] - 1
if now + 1 in loop_list:
s_index = loop_list.index(now + 1)
before_loop = s_index
loop_list = loop_list[s_index:]
break
else:
loop_list.append(now + 1)
l = len(loop_list)
k -= before_loop
# print(loop_list, l, before_loop)
print((loop_list[k % l - 1]))
else:
for _ in range(k):
now = a[now] - 1
print((now + 1))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4 5
3 2 4 1"""
output = """4"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """6 727202214173249351
6 5 2 5 3 2"""
output = """2"""
self.assertIO(input, output)
if __name__ == "__main__":
# unittest.main()
resolve()
| import sys
from io import StringIO
import unittest
def resolve():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
loop_list = []
loop_set = set()
now = 0
if k > n:
for _ in range(k):
now = a[now] - 1
if now + 1 in loop_set:
s_index = loop_list.index(now + 1)
before_loop = s_index
loop_list = loop_list[s_index:]
break
else:
loop_list.append(now + 1)
loop_set.add(now + 1)
l = len(loop_list)
k -= before_loop
# print(loop_list, l, before_loop)
print((loop_list[k % l - 1]))
else:
for _ in range(k):
now = a[now] - 1
print((now + 1))
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4 5
3 2 4 1"""
output = """4"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """6 727202214173249351
6 5 2 5 3 2"""
output = """2"""
self.assertIO(input, output)
if __name__ == "__main__":
# unittest.main()
resolve()
| p02684 |
import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [1]
for i in range(1,K + 1):
a = A[B[i - 1] - 1]
if a in B:
x = B.index(a)
y = i - x
z = (K - x) % y
print((B[x + z]))
exit()
B.append(a)
if len(B) == K + 1:
print((B[K]))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [1]
a = 1
check = [0] * len(A)
while True:
a = A[a - 1]
if check[a - 1] == 1:
x = B.index(a)
roop = B[x:]
print((roop[(K - x) % len(roop)]))
exit()
B.append(a)
check[a - 1] += 1
if len(B) >= K + 1:
print((B[K]))
exit()
if __name__ == '__main__':
main() | p02684 |
#####################################################################################################
##### 深さ優先探索 幅優先探索 （グラフ）
#####################################################################################################
'''
キューに頂点を入れる回数は各々高々１回のみ。
各辺を使う回数は高々一回のみ（辺を戻るような探索は枝切りされている）
結果として、計算量はO(N + M)
'''
from collections import deque
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def bfs(conj, start, goal=None, visit=set()):
visit.add(start) # スタート地点はすでに訪れている
next_set = deque([(start, 0)]) # 次に進む候補を列挙する。スタック（右から取り出す = pop）だと深さ優先になり、キュー（左から取り出す = popleft）だと幅優先になる
# 第一成分はスタート地点、第二成分は時刻を表す。
while next_set: # p = [] になったら止める
p, t = next_set.popleft() # 要素を消去して、消去した要素を出力
for q in conj[p]: # 頂点 p から進める経路の候補から一つ選ぶ
if q in visit: # 一度訪れていた場合は進まない
continue
if q == goal: # ゴールがあるならば、ここで判定
return t + 1 # 経路の長さは t + 1 で与えられる
visit.add(q) # 頂点 q に一度訪れた事をメモ (for の前に書くと、ここで選ばれた q が最短であるはずなのに、違う経路でvisit = Trueを踏んでしまう可能性がある)
next_set.append((q, t + 1)) # p から q へと移動。時刻を 1 進める
return -1
def connection_counter(conj): # conj の連結成分の個数を返す。関数 bfs が必要
cnt = 0
visit = set()
for start in range(N):
if start not in visit:
cnt += 1
bfs(start, conj, visit)
return cnt
def distance_list(conj, start, visit=set()): # スタート地点からの距離の全列挙
dist = [0]*N
visit.add(start)
next_set = deque([(start, 0)])
while next_set:
p, t = next_set.popleft()
for q in conj[p]:
if q in visit:
continue
dist[q] = t+1
visit.add(q)
next_set.append((q, t + 1))
return dist
def dfs(conj, start, goal=None, visit=set()):
visit.add(start) # スタート地点はすでに訪れている
next_set = [(start, 0)] # 次に進む候補を列挙する。スタック（右から取り出す = pop）だと深さ優先になり、キュー（左から取り出す = popleft）だと幅優先になる
# 第一成分はスタート地点、第二成分は時刻を表す。
while next_set: # p = [] になったら止める
p, t = next_set.pop() # 要素を消去して、消去した要素を出力
for q in conj[p]: # 頂点 p から進める経路の候補から一つ選ぶ
if q in visit: # 一度訪れていた場合は進まない
continue
if q == goal: # ゴールがあるならば、ここで判定
return t + 1 # 経路の長さは t + 1 で与えられるる
visit.add(q) # 頂点 q に一度訪れた事をメモ (for の前に書くと、ここで選ばれた q が最短であるはずなのに、違う経路でvisit = Trueを踏んでしまう可能性がある)
next_set.append((q, t + 1)) # p から q へと移動。時刻を 1 進める
return -1
#############################################################
# キャッシュにメモしながら動的計画法を行う場合など、
# 帰りがけ時に子ノードたちの結果をまとめるような処理が重要な場合には、
# 再帰関数を用いた DFS が簡明 (メモ化再帰)。
#############################################################
def dfs2(conj, p=0, goal=None, t=0, past_p=None, visit=set(), second_visit=set()):
# global res
visit.add(p)
for q in conj[p]:
if q == past_p:
# 逆流した際の処理
continue
if q in second_visit:
# 帰り道に訪れた際の処理
continue
if q in visit:
continue
if q == goal:
# ゴール時の処理
# return t+1
continue
# p から q への引継ぎ処理
# res[q] += res[p]
dfs2(conj, q, goal, t+1, p, visit, second_visit)
second_visit.add(p)
# 帰り際の処置（壊した道を元に戻す等)
# visit.discard(p)
return # res
def cycle_detector(conj, p=0, t=0, dictated=False, past_p=None, path=[], visit=set(), second_visit=set(), cycle=[]):
visit.add(p)
path.append(p)
for q in sorted(conj[p]):
if not dictated:
if q == past_p:
continue
if q in second_visit:
continue
if q in visit:
if not cycle:
while path:
r = path.pop()
cycle.append(r)
if r == q:
break
continue
cycle_detector(conj, q, t+1, dictated, p, path, visit, second_visit, cycle)
second_visit.add(p)
return cycle
def tree_counter(conj, detail=False): # 木（閉路を含まない）の個数を返す。detail = True で、閉路のリストを返す
connection_number = 0
cycle_list = []
visit = set()
second_visit = set()
for start in range(N):
if start not in visit:
connection_number += 1
cycle = cycle_detector(conj, start, visit=visit, second_visit=second_visit, cycle=[])
if cycle:
cycle_list.append(cycle)
if not detail:
return connection_number - len(cycle_list)
else:
return cycle_list
def path_detector(conj, p=0, t=0, past_p=None, full_path=[], visit=set(), second_visit=set(), decrement=False): # 距離と探索経路を返す。デクリメントされている場合は、decrement=True にする
visit.add(p)
full_path.append((p + decrement,t))
for q in sorted(conj[p]):
if q == past_p:
continue
if q in second_visit:
continue
if q in visit:
continue
path_detector(conj, q, t+1, p, full_path, visit, second_visit, decrement)
second_visit.add(p)
full_path.append((p + decrement,t))
return full_path
##################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = N
conj = [set() for _ in range(N)]
for i in range(M):
u = i
v = A[i] - 1
conj[u].add(v)
p = 0
cnt = 0
if K <= N:
while cnt + 1 <= K:
p = A[p] - 1
cnt += 1
res = p + 1
else:
cycle = list(
reversed(cycle_detector(conj, p=0, t=0, dictated=True, past_p=None, path=[], visit=set(), second_visit=set(), cycle=[])))
len_cycle = len(cycle)
p = 0
cnt = 0
res = 0
if not len_cycle:
while cnt < K:
p = A[p] - 1
cnt += 1
res = p + 1
else:
while p != cycle[0]:
p = A[p] - 1
cnt += 1
k = (K - cnt) % len_cycle
res = cycle[k] + 1
print(res)
| #####################################################################################################
##### 深さ優先探索 幅優先探索 （グラフ）
#####################################################################################################
'''
キューに頂点を入れる回数は各々高々１回のみ。
各辺を使う回数は高々一回のみ（辺を戻るような探索は枝切りされている）
結果として、計算量はO(N + M)
'''
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
from copy import deepcopy
class Graph:
def __init__(self, n, dictated=False, decrement=True, edge=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.edge = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
self.info = [-1]*self.n
for x, y in edge:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edge[x].add(y)
if self.dictated == False:
self.edge[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edge[i] = set([x-1 for x in adjacent_list])
else:
self.edge[i] = set(adjacent_list)
def cycle_detector(self, start, time=0, save=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:return: 各点までの距離と何番目に発見したかを返す
"""
edge2 = deepcopy(self.edge)
if self.decrement:
start -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, time
self.parent[p] = -2
cycle_end = False
cycle_time = 0
cycle = []
while True:
if edge2[p]:
q = edge2[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if not cycle:
if q == p:
""" 自己ループの時 """
cycle.append(q + self.decrement)
cycle_end = True
else:
cycle.append(q + self.decrement)
cycle.append(p + self.decrement)
cycle_time = t
""""""""""""""""""""
continue
self.parent[q] = p
p, t = q, t + 1
else:
""" 探索完了時の処理 """
""""""""""""""""""""
if p == start and t == time:
break
p, t = self.parent[p], t-1
""" 二度目に訪問時の処理 """
if cycle and t == cycle_time - 1 and not cycle_end:
if cycle[0] == p + self.decrement:
cycle_end = True
continue
cycle.append(p + self.decrement)
cycle_time = t
""""""""""""""""""""
cycle = list(reversed(cycle))
return [cycle[-1]] + cycle[:-1]
def tree_counter(self, detail=False):
"""
:param detail: True = サイクルのリストを返す
:return: 木（閉路を含まない）の個数を返す
"""
self.parent = [-1] * self.n
connection_number = 0
cycle_list = []
for p in range(self.n):
if self.parent[p] == -1:
connection_number += 1
cycle = self.cycle_detector(p + self.decrement, save=True)
if cycle:
cycle_list.append(cycle)
if not detail:
return connection_number - len(cycle_list)
else:
return cycle_list
def draw(self):
"""
:return: グラフを可視化
"""
import matplotlib.pyplot as plt
import networkx as nx
if self.dictated:
G = nx.DiGraph()
else:
G = nx.Graph()
for x in range(self.n):
for y in self.edge[x]:
G.add_edge(x + self.decrement, y + self.decrement)
nx.draw_networkx(G)
plt.show()
##################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = N
graph = Graph(N,dictated=True)
for i in range(1,M+1):
x = i
y = A[i-1]
graph.add_edge(x, y)
p = 0
cnt = 0
if K <= N:
while cnt + 1 <= K:
p = A[p] - 1
cnt += 1
res = p + 1
else:
cycle = list(graph.cycle_detector(1))
len_cycle = len(cycle)
p = 0
cnt = 0
res = 0
while p != cycle[0] - 1:
p = A[p] - 1
cnt += 1
k = (K - cnt) % len_cycle
res = cycle[k]
print(res)
| p02684 |
#####################################################################################################
##### 深さ優先探索 幅優先探索 （グラフ）
#####################################################################################################
'''
キューに頂点を入れる回数は各々高々１回のみ。
各辺を使う回数は高々一回のみ（辺を戻るような探索は枝切りされている）
結果として、計算量はO(N + M)
'''
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
from copy import deepcopy
class Graph:
def __init__(self, n, dictated=False, decrement=True, edge=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.edge = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
self.info = [-1]*self.n
for x, y in edge:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edge[x].add(y)
if self.dictated == False:
self.edge[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edge[i] = set([x-1 for x in adjacent_list])
else:
self.edge[i] = set(adjacent_list)
def cycle_detector(self, start, time=0, save=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:return: 各点までの距離と何番目に発見したかを返す
"""
edge2 = deepcopy(self.edge)
if self.decrement:
start -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, time
self.parent[p] = -2
cycle_end = False
cycle_time = 0
cycle = []
while True:
if edge2[p]:
q = edge2[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if not cycle:
if q == p:
""" 自己ループの時 """
cycle.append(q + self.decrement)
cycle_end = True
else:
cycle.append(q + self.decrement)
cycle.append(p + self.decrement)
cycle_time = t
""""""""""""""""""""
continue
self.parent[q] = p
p, t = q, t + 1
else:
""" 探索完了時の処理 """
""""""""""""""""""""
if p == start and t == time:
break
p, t = self.parent[p], t-1
""" 二度目に訪問時の処理 """
if cycle and t == cycle_time - 1 and not cycle_end:
if cycle[0] == p + self.decrement:
cycle_end = True
continue
cycle.append(p + self.decrement)
cycle_time = t
""""""""""""""""""""
cycle = list(reversed(cycle))
return [cycle[-1]] + cycle[:-1]
def tree_counter(self, detail=False):
"""
:param detail: True = サイクルのリストを返す
:return: 木（閉路を含まない）の個数を返す
"""
self.parent = [-1] * self.n
connection_number = 0
cycle_list = []
for p in range(self.n):
if self.parent[p] == -1:
connection_number += 1
cycle = self.cycle_detector(p + self.decrement, save=True)
if cycle:
cycle_list.append(cycle)
if not detail:
return connection_number - len(cycle_list)
else:
return cycle_list
def draw(self):
"""
:return: グラフを可視化
"""
import matplotlib.pyplot as plt
import networkx as nx
if self.dictated:
G = nx.DiGraph()
else:
G = nx.Graph()
for x in range(self.n):
for y in self.edge[x]:
G.add_edge(x + self.decrement, y + self.decrement)
nx.draw_networkx(G)
plt.show()
##################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = N
graph = Graph(N,dictated=True)
for i in range(1,M+1):
x = i
y = A[i-1]
graph.add_edge(x, y)
p = 0
cnt = 0
if K <= N:
while cnt + 1 <= K:
p = A[p] - 1
cnt += 1
res = p + 1
else:
cycle = list(graph.cycle_detector(1))
len_cycle = len(cycle)
p = 0
cnt = 0
res = 0
while p != cycle[0] - 1:
p = A[p] - 1
cnt += 1
k = (K - cnt) % len_cycle
res = cycle[k]
print(res)
| # https://atcoder.jp/contests/abc167/tasks/abc167_d
'''
キューに頂点を入れる回数は各々高々１回のみ。
各辺を使う回数は高々一回のみ（辺を戻るような探索は枝切りされている）
結果として、計算量はO(N + M)
'''
import sys
input = sys.stdin.readline
import marshal
class Graph:
def __init__(self, n, dictated=False, decrement=True, destroy=False, edge=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.destroy = destroy
self.edge = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
self.info = [-1]*self.n
for x, y in edge:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edge[x].add(y)
if self.dictated == False:
self.edge[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edge[i] = set([x-1 for x in adjacent_list])
else:
self.edge[i] = set(adjacent_list)
def dfs2(self, info, start, goal=-1, time=0, save=False):
"""
:param info: 各頂点の付加情報
:param start: スタート地点
:param goal: ゴール地点
:param save: True = 前回の探索結果を保持する
:return: ゴール地点までの距離。存在しなければ -1
"""
if self.decrement:
start -= 1
goal -= 1
if not save:
self.parent = [-1] * self.n
if self.destroy:
edge2 = self.edge
else:
edge2 = marshal.loads(marshal.dumps(self.edge))
p, t = start, time
self.parent[p] = -2
while True:
if edge2[p]:
q = edge2[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
""""""""""""""""""""
continue
if q == goal:
""" ゴール時の処理"""
# return t + 1
""""""""""""""""""""
continue
""" p から q への引継ぎ"""
info[q] += info[p]
""""""""""""""""""""
self.parent[q] = p
p, t = q, t + 1
else:
""" 探索完了時の処理 """
""""""""""""""""""""
if p == start and t == time:
break
p, t = self.parent[p], t-1
""" 二度目に訪問時の処理 """
""""""""""""""""""""
return info
def cycle_detector(self, start, time=0, save=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:return: 各点までの距離と何番目に発見したかを返す
"""
if self.decrement:
start -= 1
if not save:
self.parent = [-1] * self.n
if self.destroy:
edge2 = self.edge
else:
edge2 = marshal.loads(marshal.dumps(self.edge))
p, t = start, time
self.parent[p] = -2
cycle_end = False
cycle_time = 0
cycle = []
while True:
if edge2[p]:
q = edge2[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if not cycle:
if q == p:
""" 自己ループの時 """
cycle.append(q + self.decrement)
cycle_end = True
else:
cycle.append(q + self.decrement)
cycle.append(p + self.decrement)
cycle_time = t
""""""""""""""""""""
continue
""" p から q への引継ぎ"""
""""""""""""""""""""
self.parent[q] = p
p, t = q, t + 1
else:
""" 探索完了時の処理 """
""""""""""""""""""""
if p == start and t == time:
break
p, t = self.parent[p], t-1
""" 二度目に訪問時の処理 """
if cycle and t == cycle_time - 1 and not cycle_end:
if cycle[0] == p + self.decrement:
cycle_end = True
continue
cycle.append(p + self.decrement)
cycle_time = t
""""""""""""""""""""
cycle = list(reversed(cycle))
return [cycle[-1]] + cycle[:-1]
def tree_counter(self, detail=False):
"""
:param detail: True = サイクルのリストを返す
:return: 木（閉路を含まない）の個数を返す
"""
self.parent = [-1] * self.n
connection_number = 0
cycle_list = []
for p in range(self.n):
if self.parent[p] == -1:
connection_number += 1
cycle = self.cycle_detector(p + self.decrement, save=True)
if cycle:
cycle_list.append(cycle)
if not detail:
return connection_number - len(cycle_list)
else:
return cycle_list
##################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
M = N
graph = Graph(N,dictated=True,destroy=True)
for i in range(1,M+1):
x = i
y = A[i-1]
graph.add_edge(x, y)
p = 0
cnt = 0
if K <= N:
while cnt + 1 <= K:
p = A[p] - 1
cnt += 1
res = p + 1
else:
cycle = list(graph.cycle_detector(1))
len_cycle = len(cycle)
p = 0
cnt = 0
res = 0
while p != cycle[0] - 1:
p = A[p] - 1
cnt += 1
k = (K - cnt) % len_cycle
res = cycle[k]
print(res)
| p02684 |
import sys
input = sys.stdin.readline
class Doubling:
def __init__(self, A, K_max, decrement=True):
"""
:param A: リスト。i から A[i] へと移動する
:param K_max: K_max = 2**(k_max) まで参照する可能性がある
:param decrement: True = A の要素の decrement が必要
"""
N = len(A)
k_max = K_max.bit_length()
self.N = N
self.doubling = [[None] * N for _ in range(k_max + 1)]
self.decrement = decrement
for i, a in enumerate(A):
self.doubling[0][i] = a - self.decrement
for i in range(1, k_max):
for j in range(N):
if self.doubling[i - 1][j] is None:
self.doubling[i][j] = None
else:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def apply(self, start, K):
"""
:param start: スタート地点
:param K: K回進む
:return:
"""
i = start - self.decrement
for k in range(K.bit_length()):
m = 1 << k
if m & K:
i = self.doubling[k][i]
if i is None:
break
return i + self.decrement
######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K))) | #####################################################################################################
##### ダブリング
#####################################################################################################
"""
全体の要素数がN個あって1回移動した時にどの要素に到達するのか定まっているとき、
「K個先の要素を求めるのに O(K) かかる」ような状況において
前処理：O(N logK) 時間, O(N logK) 空間
クエリ：O(logK)
で行うことができるようにするアルゴリズム
参考
https://algo-logic.info/doubling/
ベンチマーク
https://atcoder.jp/contests/abc167/submissions/15103640
"""
import sys
input = sys.stdin.readline
class Doubling:
def __init__(self, A, K_max, decrement=True):
"""
:param A: リスト。i から A[i] へと移動する
:param K_max: K_max = 2**(k_max) まで参照する可能性がある
:param decrement: True = A の要素の decrement が必要
"""
N = len(A)
k_max = K_max.bit_length()
self.N = N
self.doubling = [[-1] * N for _ in range(k_max + 1)]
self.decrement = decrement
for i, a in enumerate(A):
self.doubling[0][i] = a - self.decrement
for i in range(1, k_max):
for j in range(N):
if self.doubling[i - 1][j] == -1:
self.doubling[i][j] = -1
else:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def apply(self, start, K):
"""
:param start: スタート地点
:param K: K回進む
:return:
"""
i = start - self.decrement
for k in range(K.bit_length()):
m = 1 << k
if m & K:
i = self.doubling[k][i]
if i is None:
break
return i + self.decrement
######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K))) | p02684 |
import sys
input = sys.stdin.readline
class Doubling:
def __init__(self, A, K_max, decrement=True):
"""
:param A: リスト。i から A[i] へと移動する
:param K_max: K_max = 2**(k_max) まで参照する可能性がある
:param decrement: True = A の要素の decrement が必要
"""
self.k_max = K_max.bit_length()
self.n = len(A)
self.decrement = decrement
self.doubling = [[-1] * self.n for _ in range(self.k_max)]
for i, a in enumerate(A):
self.doubling[0][i] = a - self.decrement
for i in range(1, self.k_max):
for j in range(self.n):
if self.doubling[i - 1][j] != -1:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def apply(self, start, K):
"""
:param start: スタート地点
:param K: K回進む
:return:
"""
i = start - self.decrement
for k in range(K.bit_length()):
m = 1 << k
if m & K:
i = self.doubling[k][i]
if i is None:
break
return i + self.decrement
######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K))) | def cycle_getter(N, start):
"""
:param N: 移動回数
:param start: 初期条件
:return front: cycleまでの要素のリスト
cycle: cycle内の要素のリスト
end: cycle後の余った部分の要素のリスト
cnt: cycle回数
"""
p = start
front, cycle, end = [], [], []
cnt = 0
visit = {p:0}
L, R = N, -1
P = [p]
for i in range(1,N):
p = lift(p)
if p in visit:
"""
(L, R) = (サイクルに入るまでに移動した回数, サイクルの終端に着くまでに移動した回数)
[6,2,3,4,0,1,2] ⇒ (L, R) = (1, 6)
"""
L, R = visit[p], i
period = R-L
break
visit[p] = i
P.append(p)
front = P[:L]
if L != N:
cycle, end = P[L:R], P[L:L+(N-L)%period]
cnt = (N-L)//period
return front, cycle, end, cnt
################################################################################
import sys
input = sys.stdin.readline
def lift(x): return A[x-1]
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
front, cycle, end, cnt = cycle_getter(K+1,1)
# print(front, cycle, end, cnt)
print(((front+cycle+end)[-1])) | p02684 |
# Problem D - Teleporter
# input
N, K = list(map(int, input().split()))
a_nums = list(map(int, input().split()))
# initialization
visit_list = [0]*N
visit_list[0] = 1
pos = a_nums[0]
visit_count = 1
while visit_list[pos-1]==0 and visit_count<K:
visit_count += 1
visit_list[pos-1] = visit_count
pos = a_nums[pos-1]
visit_count += 1
# calc 1
if visit_count<K:
tmp_1 = 0
if pos==1:
tmp_1 = visit_count - visit_list[pos-1] # 周期
else:
tmp_1 = visit_count - visit_list[pos-1]
tmp_2 = (K-visit_count) % tmp_1 # 何周するのか
# tmp_2回分ループ処理を行う
for i in range(tmp_2+1):
pos = a_nums[pos-1]
# output
print(pos)
| # Problem D - Teleporter
# input
N, K = list(map(int, input().split()))
a_list = list(map(int, input().split()))
# initialization
visit_list = [0] * N
pos = a_list[0]
visit_list[pos-1] = 1
visit_count = 1
remain = K - 1
is_ok = True
ans = 0
# count
while remain>0 and is_ok:
pos = a_list[pos-1]
remain -= 1
visit_count += 1
if pos==1 or not visit_list[pos-1]==0:
tmp_1 = visit_count - visit_list[pos-1]
tmp_2 = remain % tmp_1
for t in range(tmp_2):
pos = a_list[pos-1]
is_ok = False
break
else:
if not pos==1 and visit_list[pos-1]==0:
visit_list[pos-1] = visit_count
# output
print(pos)
| p02684 |
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
checked = [0]
next_num = a[0]-1
i = 0
while True:
if i == 0:
i += 1
elif next_num in checked:
loop = checked[checked.index(next_num):]
break
checked.append(next_num)
next_num = a[next_num]-1
dif = len(checked) - len(loop)
if k <= dif:
print((checked[k]+1))
else:
k = k-dif
print((loop[k%len(loop)]+1)) | n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
checked = [0]
next_num = a[0]-1
check = [0]*n
i = 0
while True:
if i == 0:
i += 1
elif check[next_num] == 1:
loop = checked[checked.index(next_num):]
break
checked.append(next_num)
check[next_num] = 1
next_num = a[next_num]-1
dif = len(checked) - len(loop)
if k <= dif:
print((checked[k]+1))
else:
k = k-dif
print((loop[k%len(loop)]+1)) | p02684 |
n, k, *a = list(map(int, open(0).read().split()))
a = [0] + a
p = 1
while k:
if k % 2:
p = a[p]
a = [a[b] for b in a]
k //= 2
print(p) | n,k,*a=list(map(int,open(0).read().split()));a=[0]+a;p=1
while k:p=k%2and a[p]or p;a=[a[b]for b in a];k//=2
print(p) | p02684 |
data = input().rstrip().split(" ")
tele = input().rstrip().split(" ")
telepo = [int(i) for i in tele]
max = int(data[1])
limit = max
times = 0
pos = 1
experience = [1]
while max > 0:
pos = telepo[pos - 1]
max -= 1
times += 1
#print(pos)
if pos in experience:
length = len(experience) - experience.index(pos)
max = max % length
if max == 0:
break
while max > 0:
pos = telepo[pos - 1]
max -= 1
times += 1
#print(pos)
break
experience.append(pos)
print(pos) | data = input().rstrip().split(" ")
tele = input().rstrip().split(" ")
telepo = [int(i) for i in tele]
max = int(data[1])
limit = max
times = 0
pos = 1
experience = [1]
check = {1}
before = 0
while max > 0:
pos = telepo[pos - 1]
max -= 1
times += 1
before = len(check)
check.add(pos)
if before == len(check):
length = len(experience) - experience.index(pos)
max = max % length
if max == 0:
break
while max > 0:
pos = telepo[pos - 1]
max -= 1
times += 1
#print(pos)
break
experience.append(pos)
print(pos) | p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [[i - 1, j - 1] for i, j in enumerate(a)]
g = [[0 for _ in range(n)] for _ in range(n)]
x = [0]
i = 0
j = a[0][1]
while g[i][j] != 1:
x.append(j)
g[i][j] = 1
i = j
j = a[j][1]
tmp = x.index(x[-1])
if tmp >= k:
print((x[k] + 1))
else:
x = x[tmp:-1]
k = (k - tmp) % len(x)
print((x[k] + 1)) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [i - 1 for i in a]
g = [-1] * n
i = 0
j = 0
while g[j] == -1:
if i == k:
print((j + 1))
exit()
g[j] = i
i += 1
j = a[j]
for i in range((k - g[j]) % (i - g[j])):
j = a[j]
print((j + 1)) | p02684 |
n,k = list(map(int,input().split()))
a = [int(i) - 1 for i in input().split()]
r = []
nx = 0
for i in range(n):
r.append(nx)
if k < i:
print((r[k] + 1))
break
if a[nx] in r:
m = r.index(a[nx])
d = i - m + 1
k = k - m
k = k % d
print((r[k + m] + 1))
break
nx = a[nx]
| n,k = list(map(int,input().split()))
a = [int(i) - 1 for i in input().split()]
r = []
nx = 0
sr = set([])
for i in range(n):
r.append(nx)
sr.add(nx)
if k < i:
print((r[k] + 1))
break
tnx = a[nx]
if tnx in sr:
m = r.index(a[nx])
d = i - m + 1
k = k - m
k = k % d
print((r[k + m] + 1))
break
nx = tnx
| p02684 |
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1''などで指定、整数に戻すならintをかます
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(10**6+10)
input = sys.stdin.readline
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(10**6+10)
input = sys.stdin.readline
N,K = MI()
A = [0]+LI()
ans_l = [1]
next = A[1]
done = [0]*(N+1)
done[1] = 1
while done[next]==0:
ans_l.append(next)
done[next]=1
next = A[next]
idx = ans_l.index(next)
repeat = ans_l[idx:]
if K<idx:
print((ans_l[K]))
else:
print((repeat[(K-idx)%len(repeat)]))
| import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
from bisect import bisect_left
from itertools import product
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def LSI(): return list(map(int, list(sys.stdin.readline().rstrip())))
def LSI2(N): return [list(map(int, list(sys.stdin.readline().rstrip()))) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(10**6+10)
input = sys.stdin.readline
N,K = MI()
A = [0]+LI()
ans_l = []
next = 1
done = [0]*(N+1)
while done[next]==0:
ans_l.append(next)
done[next]=1
next = A[next]
idx = ans_l.index(next)
c = len(ans_l)-idx
if K<idx:
print((ans_l[K]))
else:
ans_idx = (K-idx)%c+idx
print((ans_l[ans_idx]))
| p02684 |
N,K=list(map(int,input().split()))
T=str(bin(K))
S=len(T)-2
A = list(map(int,input().split()))
lst=[[0 for e in range(N+1)] for f in range(S)]
for i in range(1,N+1):
lst[0][i]=A[i-1]
for j in range(1,S):
for i in range(1,N+1):
lst[j][i]=lst[j-1][lst[j-1][i]]
ans=[[e for e in range(N+1)] for f in range(S+1)]
for k in range(S):
if int(T[k+2])==1:
for l in range(1,N+1):
ans[k+1][l]=lst[S-1-k][ans[k][l]]
else:
for l in range(1,N+1):
ans[k+1][l]=ans[k][l]
print((ans[S][1]))
| N,K=list(map(int,input().split()))
T=str(bin(K))
S=len(T)-2
A = list(map(int,input().split()))
lst=[[0 for e in range(N+1)] for f in range(S)]
for i in range(1,N+1):
lst[0][i]=A[i-1]
for j in range(1,S):
for i in range(1,N+1):
lst[j][i]=lst[j-1][lst[j-1][i]]
ans=1
for k in range(S):
if int(T[k+2])==1:
ans=lst[S-1-k][ans]
print(ans) | p02684 |
N, K = list(map(int, input().split()))
A = tuple([int(n) - 1 for n in input().split()])
costs = [-1] * N
loc = 0
if K <= N:
for i in range(K):
loc = A[loc]
print((loc + 1))
else:
costs[loc] = 0
for i in range(1, K):
loc = A[loc]
if costs[loc] >= 0:
break
costs[loc] = i
offset = costs[loc]
loop = i - offset
K -= i
K %= loop
for _ in range(K):
loc = A[loc]
print((loc + 1)) | N, K = list(map(int, input().split()))
# A = tuple(map(lambda n: int(n) - 1, input().split()))
A = tuple(map(int, input().split()))
costs = [-1] * N
loc = 1
if K <= N:
for i in range(K):
loc = A[loc - 1]
print(loc)
else:
costs[loc - 1] = 0
for i in range(1, K):
loc = A[loc - 1]
if costs[loc - 1] >= 0:
break
costs[loc - 1] = i
offset = costs[loc - 1]
loop = i - offset
K -= i
K %= loop
for _ in range(K):
loc = A[loc - 1]
print(loc) | p02684 |
N,K=list(map(int,input().split()))
*A,=list(map(int,input().split()))
point=[0]*N
count_X=0
count_Y=0
i=0
while all(j<3 for j in point):
if all(j<2 for j in point):
count_X+=1
point[i]+=1
i=A[i]-1
if any(k>1 for k in point):
count_Y+=1
count_Y-=1
if K>=count_X:
Z=count_X+(K-count_X)%count_Y
else:
Z=K
i=0
ans=1
while i<Z:
ans=A[ans-1]
i+=1
print(ans)
| N,K=list(map(int,input().split()))
*A,=list(map(int,input().split()))
point=[0]*N
count_X=0
count_Y=0
i=0
while point[i]!=3:
if point[i]<2:
count_X+=1
point[i]+=1
i=A[i]-1
if point[i]>1:
count_Y+=1
count_Y-=1
if K>=count_X:
Z=count_X+(K-count_X)%count_Y
else:
Z=K
i=0
ans=1
while i<Z:
ans=A[ans-1]
i+=1
print(ans) | p02684 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
l = [A[0]]
a = A[0] - 1
for _ in range(K):
if A[a] not in l:
l.append(A[a])
a = A[a] - 1
else:
a = A[a]
break
n = len(l)
b = 0
for i in range(n):
if l[i] == a:
del l[0:i]
b = i
break
T = len(l)
S = (K - b) % T
ans = l[S - 1]
print(ans)
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
l = [A[0]]
s = {A[0]}
a = A[0] - 1
for _ in range(K):
if A[a] not in s:
l.append(A[a])
s.add(A[a])
a = A[a] - 1
else:
a = A[a]
break
n = len(l)
b = 0
for i in range(n):
if l[i] == a:
del l[0:i]
b = i
break
T = len(l)
S = (K - b) % T
ans = l[S - 1]
print(ans)
| p02684 |
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(eval(input()))
mis = lambda: list(map(int, input().split()))
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7
def meg(f, ok, ng):
while abs(ok-ng)>1:
mid = (ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
def get_inv(n, modp):
return pow(n, modp-2, modp)
def factorials_list(n, modp): # 10**6
fs = [1]
for i in range(1, n+1):
fs.append(fs[-1] * i % modp)
return fs
def invs_list(n, fs, modp): # 10**6
invs = [get_inv(fs[-1], modp)]
for i in range(n, 1-1, -1):
invs.append(invs[-1] * i % modp)
invs.reverse()
return invs
def comb(n, k, modp):
num = 1
for i in range(n, n-k, -1):
num = num * i % modp
den = 1
for i in range(2, k+1):
den = den * i % modp
return num * get_inv(den, modp) % modp
def comb_from_list(n, k, modp, fs, invs):
return fs[n] * invs[n-k] * invs[k] % modp
#
class UnionFindEx:
def __init__(self, size):
#正なら根の番号、負ならグループサイズ
self.roots = [-1] * size
def getRootID(self, i):
r = self.roots[i]
if r < 0: #負なら根
return i
else:
r = self.getRootID(r)
self.roots[i] = r
return r
def getGroupSize(self, i):
return -self.roots[self.getRootID(i)]
def connect(self, i, j):
r1, r2 = self.getRootID(i), self.getRootID(j)
if r1 == r2:
return False
if self.getGroupSize(r1) < self.getGroupSize(r2):
r1, r2 = r2, r1
self.roots[r1] += self.roots[r2] #サイズ更新
self.roots[r2] = r1
return True
Yes = 'Yes'
No = 'No'
def main():
N, K = mis()
A = [a-1 for a in mis()]
B = [None]*N
now = 0
B[now] = 0
for i in range(1, K+1):
now = A[now]
K -= 1
if B[now] is not None:
K %= (i - B[now])
break
B[now] = i
for _ in range(K):
now = A[now]
print((now+1))
main()
| '''
・基本的には素直なシミュレーションを行う
・ループ分のシミュレーションを省略することでTLEを回避
・Kは「残りのワープ数」と考える
K回のワープ中にループが含まれる場合、
1. 素直なシミュレーションを行う。このとき、Kを減算していく。
2. ループを検出したら、Kからループ長をできるだけ多く引くことで、計算を省略する。
3. 残りのステップ数、再度シミュレーションを行う
という手順で答えを求められる。
なお、ループが含まれない場合も1のみで答えを求められる。
'''
def main():
N, K = list(map(int, input().split()))
A = [a-1 for a in map(int, input().split())] # 0-indexed に変換
B = [None]*N # 何ステップ目に到達したかを記録。Noneなら未到達を表す
now = 0 # 現在地
step = 0 # ステップ数
B[now] = 0 # 開始地点は、0ステップ目に到達済みとする
while K:
now = A[now] # 現在地を更新
step += 1
K -= 1
if B[now] is not None: # ループを検出したら...
K %= (step - B[now]) # Kからループ長さを引けるだけ引く
else:
B[now] = step # 到達したステップ数を記録
print((now+1)) # 1-indexed に再変換
main()
| p02684 |
from collections import deque
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
g = [i for i in range(n)]
for i in range(n):
g[i] = a[i]-1
dist =[-1]*n
dist[0] = 0
q = deque([0])
hajimari = -1
loopnum = -1
while q:
v = q.popleft()
u = g[v]
if dist[u] == -1:
dist[u] = dist[v]+1
q.append(u)
else:
hajimari = u
loopnum = dist[v] + 1 - dist[u]
break
if hajimari != -1:
break
if k <= dist[hajimari]:
now = 0
for _ in range(k):
now = g[now]
print((now+1))
else:
now = hajimari
for _ in range((k-dist[hajimari])%loopnum):
now = g[now]
print((now+1)) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
dist = [-1] * n
dist[0] = 0
now = 0
while True:
next = a[now] - 1
if dist[next] == -1:
dist[next] = dist[now] + 1
else:
hajimari = next
loopnum = dist[now] + 1 - dist[hajimari]
town = 0
if k <= dist[hajimari]:
for _ in range(k):
town = a[town] - 1
else:
town = hajimari
for _ in range((k - dist[hajimari]) % loopnum):
town = a[town] - 1
print((town + 1))
exit()
now = next | p02684 |
n,k = (int(x) for x in input().split())
a =tuple([int(x) for x in input().split()])
l = [1]
now = 1
notloop = 0
dupl = -1
for i in range(k):
now = a[now - 1]
if now in l:
dupl = now
break
else:
l.append(now)
if(dupl == -1):
print(now)
else:
notloop = l.index(dupl)
length = len(l)-notloop
print((l[(k-notloop)%length+notloop])) | n,k = (int(x) for x in input().split())
a = tuple([int(x) for x in input().split()])
c = [0] + [-1]*(n)
l = [1]
now = 1
dupl = -1
for i in range(k):
now = a[now - 1]
c[now - 1] += 1
if c[now - 1] == 1:
dupl = now
break
else:
l.append(now)
if dupl == -1:
print(now)
exit()
notloop = l.index(dupl)
length = len(l)-notloop
print((l[(k-notloop)%length+notloop])) | p02684 |
def main():
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
from collections import deque
q = deque()
p = deque()
q.append(1)
buf = 0
flg = True
idx = 1
cnt = 0
while flg:
buf = idx
idx = a[idx-1]
cnt += 1
if cnt == k:
print(idx)
return 0
if idx in q:
flg = False
else:
q.append(idx)
for i in range(len(q)):
tmp = q.pop()
p.appendleft(tmp)
if tmp == idx:
break
if k < len(q):
print((list(q)[k%len(q)]))
else:
k -= len(q)
print((list(p)[k%len(p)]))
return 0
if __name__ == '__main__':
main()
| def main():
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
# k<=10**18 < 2**60
r = 60
import math
r = math.ceil(math.log2(k))
idx = 0
a = [a[i]-1 for i in range(n)]
for i in range(r):
if (k>>i)&1 == 1:
idx = a[idx]
a = [a[a[j]] for j in range(n)]
print((idx+1))
if __name__ == '__main__':
main() | p02684 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import math
# 標準入力の取得
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 求解処理
to = [A]
# ダブリング表の作成
for i in range(math.ceil(math.log2(K))):
to_i = to[i]
to_next = []
for j in range(N):
to_next.append(to_i[to_i[j]-1])
to.append(to_next)
result = 1
for i in range(math.ceil(math.log2(K))):
if ((K >> i) & 1):
result = to[i][result-1]
print(result)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import math
def get_input() -> tuple:
"""
標準入力の取得
Returns:\n
tuple: 標準入力
"""
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
return N, K, A
def main(N: int, K: int, A: list) -> None:
"""
求解処理.
Args:
N (int): 町の数
K (int): テレポーターの使用回数
A (list): テレポーターの転送先
"""
# タブリング表の作成
to = [A]
for i in range(math.ceil(math.log2(K))):
to_i = to[i]
to_next = []
for j in range(N):
to_next.append(to_i[to_i[j]-1])
to.append(to_next)
result = 1
for i in range(math.ceil(math.log2(K))):
if ((K >> i) & 1):
result = to[i][result-1]
print(result)
if __name__ == "__main__":
N, K, A = get_input()
main(N, K, A)
| p02684 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import math
def get_input() -> tuple:
"""
標準入力の取得
Returns:\n
tuple: 標準入力
"""
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
return N, K, A
def main(N: int, K: int, A: list) -> None:
"""
求解処理.
Args:\n
N (int): 町の数
K (int): テレポーターの使用回数
A (list): テレポーターの転送先
"""
# タブリング表の作成
bit_num = math.ceil(math.log2(K))
to = [A]
for i in range(bit_num):
to_i = to[i]
to_next = []
for j in range(N):
to_next.append(to_i[to_i[j]-1])
to.append(to_next)
# 到着する街の計算
result = 1
for i in range(bit_num):
if ((K >> i) & 1):
result = to[i][result-1]
# 結果出力
print(result)
if __name__ == "__main__":
N, K, A = get_input()
main(N, K, A)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import math
def get_input() -> tuple:
"""
標準入力の取得
Returns:\n
tuple: 標準入力
"""
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
return N, K, A
def main(N: int, K: int, A: list) -> None:
"""
求解処理.
Args:\n
N (int): 町の数
K (int): テレポーターの使用回数
A (list): テレポーターの転送先
"""
# タブリング表の作成
to = [A]
for i in range(math.ceil(math.log2(K))):
to_i = to[i]
to_next = []
for j in range(N):
to_next.append(to_i[to_i[j]-1])
to.append(to_next)
# 到着する町の計算
result = 1
for i in range(math.ceil(math.log2(K))):
if ((K >> i) & 1):
result = to[i][result-1]
# 結果出力
print(result)
if __name__ == "__main__":
N, K, A = get_input()
main(N, K, A)
| p02684 |
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(10**5*2)
def search(u, n, g, disc, k):
if disc[u] != None:
circles = n - disc[u]
v = (k - disc[u]) % circles
ans = u
if n > k:
ans = 0
for _ in range(k):
ans = g[ans]
return ans + 1
for i in range(v):
ans = g[ans]
return ans + 1
disc[u] = n
return search(g[u], n+1, g, disc, k)
def resolve():
n, k = list(map(int, input().split()))
g = list([int(x) - 1 for x in input().split()])
disc = [None]*n
v = search(0, 0, g, disc, k)
print(v)
resolve() | def resolve():
n, k = list(map(int, input().split()))
g = list(map(int, input().split()))
disc = [-1]*(n+1)
s = []
v = 1
c = 0
while disc[v] == -1:
disc[v] = len(s)
s.append(v)
v = g[v-1]
c = len(s) - disc[v]
l = len(s)
if l > k:
print((s[k]))
else:
r = (k - disc[v]) % c
for i in range(r):
v = g[v-1]
print(v)
resolve() | p02684 |
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(10**6)
def search(n, step, rec, seq, k):
if rec[n] != -1:
c = step - rec[n]
sim = (k - rec[n]) % c
v = n
for i in range(sim):
v = seq[v-1]
print(v)
return
rec[n] = step
if step == k:
print(n)
return
search(seq[n-1], step + 1, rec, seq, k)
def resolve():
n, k = list(map(int, input().split()))
seq = list(map(int, input().split()))
rec = [-1]*(n+1)
search(1, 0, rec, seq, k)
resolve() | def resolve():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
rec = [True]*(n+2)
now = 0
stp = [1]
while rec[now]:
rec[now] = False
now = a[now] - 1
stp.append(now+1)
before_loop = stp.index(now+1)
loop = stp[before_loop:-1]
if k <= (before_loop + 1):
print((stp[k]))
else:
r = (k - before_loop) % len(loop)
print((loop[r]))
resolve() | p02684 |
def resolve():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
rec = [True]*(n+2)
now = 0
stp = [1]
while rec[now]:
rec[now] = False
now = a[now] - 1
stp.append(now+1)
before_loop = stp.index(now+1)
loop = stp[before_loop:-1]
if k <= (before_loop + 1):
print((stp[k]))
else:
r = (k - before_loop) % len(loop)
print((loop[r]))
resolve() | def resolve():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
rec = [True]*(n+2)
now = 0
stp = [1]
while rec[now]:
rec[now] = False
now = a[now] - 1
stp.append(now+1)
before_loop = stp.index(now+1)
loop = stp[before_loop:-1]
if k <= (before_loop):
print((stp[k]))
else:
r = (k - before_loop) % len(loop)
print((loop[r]))
resolve() | p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = {i:[] for i in range(n)}
ans = 0
for i in range(k):
b[a[ans]-1].append(ans)
if len(b[a[ans]-1]) == 2:
c = [ans]
ans = a[ans]-1
while ans != c[0]:
c.append(ans)
ans = a[ans]-1
ans = c[(k-i) % len(c)]
break
ans = a[ans]-1
print((ans+1)) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
s = [-1]*n
c = []
ans = 0
for i in range(k):
s[ans] = i
c.append(ans)
ans = a[ans] - 1
if s[ans] >= 0:
t = i - s[ans] + 1
ans = c[(k-i-1) % t + s[ans]]
break
print((ans+1)) | p02684 |
n, k = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
a = [0] + a
rep_check = 0
now = 1
place = []
if now == a[1]:
print((1))
exit()
while now not in place:
place.append(now)
now = a[now]
rep_check += 1
if rep_check == k:
print(now)
exit()
rep_start = 0
for i in enumerate(place):
if i[1] == now:
rep_start = i[0]
break
k -= rep_start
rep_cnt = len(place) - rep_start
place = place[rep_start:]
k %= rep_cnt
print((place[k])) | n, k = list(map(int, input().split()))
a = [int(_) for _ in input().split()]
a = [0] + a
rep_check = 0
now = 1
place = dict()
place2 = []
if now == a[1]:
print((1))
exit()
while now not in place:
place[now] = 1
place2.append(now)
now = a[now]
rep_check += 1
if rep_check == k:
print(now)
exit()
rep_start = 0
for i in enumerate(place):
if i[1] == now:
rep_start = i[0]
break
k -= rep_start
rep_cnt = len(place) - rep_start
place2 = place2[rep_start:]
k %= rep_cnt
print((place2[k])) | p02684 |
import sys
sys.setrecursionlimit(10**7) #再帰回数の上限を変更
from collections import deque
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
L=[]
chk=[0 for _ in range(N)]
tmp=0
while(1):
if chk[tmp]==1:
break
chk[tmp]=1
L.append(tmp)
tmp=A[tmp]-1
loop_s=A[L[-1]-1]-1
loop_g=L[-1]-1
one_to_s=0
tmp=0
while(1):
if tmp==loop_s:
break
tmp=A[tmp]-1
one_to_s+=1
loop_l=0
tmp=loop_s
Loop=[loop_s]
while(1):
if tmp==loop_g:
break
tmp=A[tmp]-1
Loop.append(tmp)
loop_l+=1
loop_l+=1
if K<=one_to_s:
tmp=0
cnt=0
while(1):
if cnt==K:
break
tmp=A[tmp]-1
cnt+=1
ans=tmp + 1
else:
K-=one_to_s
num=K%loop_l
ans=Loop[num]+1
print(ans) | import sys
sys.setrecursionlimit(10**7) #再帰回数の上限を変更
from collections import deque
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
L=[]
chk=[0 for _ in range(N)]
tmp=0
while(1):
if chk[tmp]==1:
break
chk[tmp]=1
L.append(tmp)
tmp=A[tmp]-1
#print(L)
loop_s=A[L[-1]]-1
loop_g=L[-1]
one_to_s=0
tmp=0
#print(loop_s)
#print(loop_g)
while(1):
if tmp==loop_s:
break
tmp=A[tmp]-1
#print(tmp)
one_to_s+=1
loop_l=0
tmp=loop_s
Loop=[loop_s]
while(1):
if tmp==loop_g:
break
tmp=A[tmp]-1
Loop.append(tmp)
loop_l+=1
loop_l+=1
#print(one_to_s)
if K<=one_to_s:
tmp=0
#print("ON")
cnt=0
while(1):
if cnt==K:
break
tmp=A[tmp]-1
cnt+=1
ans=tmp + 1
else:
K-=one_to_s
num=K%loop_l
ans=Loop[num]+1
print(ans) | p02684 |
N, K = [int(x) for x in input().split()]
A = [int(x)-1 for x in input().split()]
past = 0
history = [0]
while True:
na = A[past]
if na in history:
break
history.append(na)
past = na
s = history.index(na)
e = len(history)
loop = e - s
if K <= s: # ループ前終了
print((history[K]+1))
else:
k = K - s
print((history[s+(k%loop)]+1))
| N, K = [int(x) for x in input().split()]
A = [int(x)-1 for x in input().split()]
past = 0
history = [0]
s = set()
while True:
na = A[past]
if na in s:
break
s.add(na)
history.append(na)
past = na
s = history.index(na)
e = len(history)
loop = e - s
if K <= s: # ループ前終了
print((history[K]+1))
else:
k = K - s
print((history[s+(k%loop)]+1))
| p02684 |
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
ans=0
now=1
i=1
result=[1]
while i<=k:
now=a[now-1]
if now in result:
x=result.index(now)
length=i-x
ans=result[(k-x)%length+x]
break
result.append(now)
i+=1
if ans!=0:
print(ans)
else:
print((result[-1])) | n,k=list(map(int,input().split()))
a=list([int(x)-1 for x in input().split()])
ans=-1
l=[-1]*n
now=0
i=1
result=[0]
while i<=k:
now=a[now]
if l[now]!=-1:
length=i-l[now]
d=(k-i)%length+l[now]
ans=l.index(d)
break
l[now]=i
i+=1
if ans!=-1:
print((ans+1))
else:
print((now+1)) | p02684 |
n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
tel_list = []
next_city = 0
city_have_been_to = set([0])
way = [0]
while k > 0:
k -= 1
temp = city_have_been_to.copy()
next_city = a[next_city] - 1
city_have_been_to.add(next_city)
way.append(next_city)
if temp == city_have_been_to:
break
if k == 0:
print((way[-1] + 1))
else:
temp_index = way.index(next_city)
print((way[temp_index:-1][k % len(way[temp_index:-1])] + 1))
| n, k = list(map(int,input().split()))
a = list(map(int,input().split()))
tel_list = []
next_city = 0
city_have_been_to = set([0])
way = [0]
while k > 0:
k -= 1
temp = len(city_have_been_to)
next_city = a[next_city] - 1
city_have_been_to.add(next_city)
way.append(next_city)
if temp == len(city_have_been_to):
break
if k == 0:
print((way[-1] + 1))
else:
temp_index = way.index(next_city)
print((way[temp_index:-1][k % len(way[temp_index:-1])] + 1)) | p02684 |
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]
def solve():
N, K = IL(int)
A = IL(lambda x: int(x) - 1)
memo = [0]
i = 0
while(not A[i] in memo):
memo.append(A[i])
idx = i
i = A[i]
if K < len(memo):
print((memo[K] + 1))
else:
loop = memo[memo.index(A[i]):]
print((loop[(K - (len(memo) - len(loop))) % len(loop)] + 1))
solve()
| #!/usr/bin/env python3
import sys
input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]
def solve():
N, K = IL(int)
A = IL(lambda x: int(x) - 1)
memo = [0]
visited = [False] * N
i = 0
while(not visited[A[i]]):
memo.append(A[i])
visited[A[i]] = True
i = A[i]
if K < len(memo):
print((memo[K] + 1))
else:
loop = memo[memo.index(A[i]):]
print((loop[(K - (len(memo) - len(loop))) % len(loop)] + 1))
solve()
| p02684 |
cin = open(0).read().strip().split('\n')
n,k = list(map(int, cin[0].split(' ')))
a = list(map(int, cin[1].split(' ')))
place = 1
history = []
rule = []
while len(rule) == 0:
history.append(place)
place = a[place-1]
for i in range(1,len(history)//2+1):
aset = set(history[len(history)-i*2:len(history)-i])
bset = set(history[len(history)-i:])
# print(i, history, aset, bset)
if aset == bset:
rule = history[len(history)-i:]
if len(history) == (k+1):
break
if len(rule) == 0:
print((history[k]))
else:
pre = len(history)-len(rule)*2
mod = (k-(pre-1)) % len(rule)
print((rule[mod-1])) | cin = open(0).read().strip().split('\n')
n,k = list(map(int, cin[0].split(' ')))
a = list(map(int, cin[1].split(' ')))
history = [1]
for i in range(n):
history.append(a[history[i]-1])
if n >= k:
print((history[k]))
else:
times = [-1] * n
for i in range(n):
if times[history[i]-1] == -1:
times[history[i]-1] = i
else:
cycle = i-times[history[i]-1]
pre = times[history[i]-1]
mod = (k-pre)%cycle
print((history[pre+mod]))
break
| p02684 |
N, K = list(map(int, input().split()))
A = list([int(x)-1 for x in input().split()])
town = 0
visited = [town]
loop = None
while K > 0:
K -= 1
town = A[town]
if town in visited:
loop = visited[visited.index(town):]
break
visited.append(town)
if loop:
K %= len(loop)
print((loop[K]+1))
else:
print((town+1))
| N, K = list(map(int, input().split()))
A = list([int(x)-1 for x in input().split()])
town = 0
visited = [town]
index = 0
visited_index = {town: index}
loop = None
while K > 0:
K -= 1
town = A[town]
if town in visited_index:
loop = visited[visited_index[town]:]
break
visited.append(town)
index += 1
visited_index[town] = index
if loop:
K %= len(loop)
print((loop[K]+1))
else:
print((town+1))
| p02684 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
loop_checker = [1]
before_loop_len = 0
loop_len = 0
now = 0
while True:
if A[now] in loop_checker:
before_loop_len = loop_checker.index(A[now])
loop_slice = loop_checker[before_loop_len:]
loop_len = len(loop_slice)
break
else:
loop_checker.append(A[now])
now = A[now] - 1
if K <= before_loop_len:
print((loop_checker[K]))
else:
checkK_prep = (K - before_loop_len)
checkK = checkK_prep % loop_len
print((loop_slice[checkK]))
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
flag = [False] * N
counted = [1]
nextT = A[0]
flag[0] = True
for x in range(N):
if flag[nextT - 1] is False:
counted.append(nextT)
flag[nextT - 1] = True
nextT = A[nextT - 1]
else:
break
before_loop_len = counted.index(nextT)
loop_len = x - before_loop_len + 1
if K <= before_loop_len:
print((counted[K]))
else:
checkK_prep = K - before_loop_len
checkK = checkK_prep % loop_len
print((counted[before_loop_len + checkK]))
| p02684 |
n,k = list(map(int, input().split()))
A = list(map(int, input().split()))
now = 1
f = 0
past = [0]*n
if n>k:
for i in range(k):
now = A[now-1]
print(now)
exit()
c = 0
for i in range(n):
past[c] = now
now = A[now-1]
c+=1
if now in past:
f = 1
break
loop_end = c
loop_start = past.index(now)
#print(past, now, loop_end, loop_start)
res = (k-loop_start)%(loop_end-loop_start)
now = past[loop_start]
for i in range(res):
now = A[now-1]
print(now)
| n,k = list(map(int, input().split()))
b = list(map(int, input().split()))
a=0
for i in range(n):
b[i] -= 1
if k<n:
for i in range(k):
a = b[a]
print((a+1))
exit()
c = [-1]*n
cc = 0
se = set()
while a not in se:
c[a] = cc
cc += 1
se.add(a)
a = b[a]
for i in range((k-c[a])%(cc-c[a])):
a = b[a]
print((a+1)) | p02684 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for idx, a in enumerate(A):
tree[a - 1].append(idx)
tree[idx].append(a - 1)
start = []
depth = [0 for _ in range(n)]
def dfs(v, p, d):
depth[v] = d
for u in tree[v]:
if u == p:
continue
if visited[u]:
start.append([u + 1, depth[u]])
return
else:
visited[u] = True
dfs(u, v, d + 1)
return
visited = [False for _ in range(n)]
visited[0] = True
dfs(0, -1, 0)
for i in range(n):
if i + 1 not in set(A):
depth[i] = 0
if k <= start[0][1]:
print((depth.index(k) + 1))
elif len(start) == 1:
print((start[0][0]))
else:
cnt = (k - start[0][1]) % (start[-1][1] - start[0][1] + 1)
res = start[0][1] + cnt
print((depth.index(res) + 1))
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for idx, a in enumerate(A):
tree[idx].append(a - 1)
start = []
depth = [0 for _ in range(n)]
def dfs(v, p, d, cnt):
depth[v] = d
for u in tree[v]:
if visited[u]:
start.append([u + 1, depth[u], cnt + 1])
return
else:
visited[u] = True
dfs(u, v, d + 1, cnt + 1)
return
visited = [False for _ in range(n)]
visited[0] = True
dfs(0, -1, 0, 0)
if k <= start[0][1]:
print((depth.index(k) + 1))
else:
cnt = (k - start[0][1]) % (start[0][2] - start[0][1])
res = start[0][1] + cnt
print((depth.index(res) + 1))
if __name__ == '__main__':
resolve()
| p02684 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for idx, a in enumerate(A):
tree[idx].append(a - 1)
start = []
depth = [0 for _ in range(n)]
def dfs(v, p, d, cnt):
depth[v] = d
for u in tree[v]:
if visited[u]:
start.append([u + 1, depth[u], cnt + 1])
return
else:
visited[u] = True
dfs(u, v, d + 1, cnt + 1)
return
visited = [False for _ in range(n)]
visited[0] = True
dfs(0, -1, 0, 0)
if k <= start[0][1]:
print((depth.index(k) + 1))
else:
cnt = (k - start[0][1]) % (start[0][2] - start[0][1])
res = start[0][1] + cnt
print((depth.index(res) + 1))
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for idx, a in enumerate(A):
tree[idx].append(a - 1)
def dfs(pre, dist):
depth[pre] = dist
for to in tree[pre]:
if depth[to] != f_inf:
cycle.append([depth[to], depth[pre] + 1])
return
else:
dfs(to, dist + 1)
cycle = []
depth = [f_inf for _ in range(n)]
dfs(0, 0)
cycle_start = cycle[0][0]
cycle_end = cycle[0][1]
if k <= cycle_start:
print((depth.index(k) + 1))
else:
remainder = (k - cycle_start) % (cycle_end - cycle_start)
res = cycle_start + remainder
print((depth.index(res) + 1))
if __name__ == '__main__':
resolve()
| p02684 |
def main():
n, k = list(map(int, input().split()))
al = list(map(int, input().split()))
city_l = [1]
city_s = set([1])
loop_city_l = []
curr_city = 1
cnt = 0
for i in range(1,k+1):
next_c = al[curr_city-1]
if next_c in city_s:
cnt = i
first_city = city_l.index(next_c)
loop_city_l = city_l[first_city:]
break
else:
city_s.add(next_c)
city_l.append(next_c)
curr_city = next_c
else:
print(curr_city)
return
# print(loop_city_l)
remained = k-cnt
last_pos = remained%len(loop_city_l)
print((loop_city_l[last_pos]))
if __name__ == "__main__":
main() | n,k = list(map(int, input().split()))
al = list(map(int, input().split()))
cnt = 0
cl = [-1]*(n+1)
cll = [1]
curr = 1
for i in range(min(n,k)):
# print(curr)
next_c = al[curr-1]
if cl[next_c] != -1:
# loop_start = (i+1)
loop_start = cl[next_c]
rem = k - (i+1)
break
else:
cl[next_c] = i + 1
cll.append(next_c)
curr = next_c
else:
print(curr)
exit()
# print(rem)
loop_c = cll[loop_start:]
# print(loop_c)
last_ind = rem%len(loop_c)
ans = loop_c[last_ind]
print(ans) | p02684 |
n, k = list(map(int, input().split(" ")))
a = [-1] + list(map(int, input().split(" ")))
i = 1
head = []
used = []
roop = []
inte=False
for _ in range(k):
i = a[i]
if i in used:
used.append(i)
head = used[0: used.index(i)]
roop = used[used.index(i): -1]
inte =True
break
else:
used.append(i)
if inte:
if len(head) >= k:
print((head[k-1]))
else:
x = (k - 1 - len(head)) % len(roop)
print((roop[x]))
else:
print((used[k-1]))
| import sys
n, k = list(map(int, input().split(" ")))
a = [-1] + list(map(int, input().split(" ")))
i = 1
head = []
used = {}
roop = []
index = 0
for _ in range(k):
index += 1
i = a[i]
if i in used:
head = [ k for k, v in sorted(list(used.items()), key=lambda x:x[1]) if v < used[i]]
roop = [ k for k, v in sorted(list(used.items()), key=lambda x:x[1]) if v >= used[i]]
if len(head) >= k:
print((head[k-1]))
else:
x = (k - 1 - len(head)) % len(roop)
print((roop[x]))
sys.exit()
else:
used[i] = index
print(([ k for k, v in sorted(list(used.items()), key=lambda x:x[1])][k-1])) | p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
history = []
index = 0
cnt = 0
loop_start_city_index = 0
for i in range(k+1):
if i == k:
print((index+1))
exit()
if index in history: # すでに訪れた街にきた
loop_start_city_index = index
break
history.append(index)
index = a[index] - 1
cnt += 1
from_start_to_loop_start = history.index(loop_start_city_index)
loop_length = len(history) - from_start_to_loop_start
print((history[from_start_to_loop_start + (k-from_start_to_loop_start)%loop_length] + 1)) | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
history = []
is_visited = [False] * n
index = 0
cnt = 0
loop_start_city_index = 0
for i in range(k+1):
if i == k:
print((index+1))
exit()
if is_visited[index]: # すでに訪れた街にきた
loop_start_city_index = index
break
is_visited[index] = True
history.append(index)
index = a[index] - 1
cnt += 1
from_start_to_loop_start = history.index(loop_start_city_index)
loop_length = len(history) - from_start_to_loop_start
print((history[from_start_to_loop_start + (k-from_start_to_loop_start)%loop_length] + 1)) | p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
num = 1
li = [1]
flag = [True] * n
flag[0] = False
for i in range(k):
num = a[num-1]
if flag[num-1]:
li.append(num)
flag[num-1] = False
else:
break
d = li.index(num)
ans = (k-d)%(len(li)-d)+d
print((li[ans])) | n, k = list(map(int, input().split()))
a = [0]+list(map(int, input().split()))
num = 1
li = [1]
flag = [True] * n
flag[0] = False
for i in range(k):
num = a[num]
if flag[num-1]:
li.append(num)
flag[num-1] = False
else:
break
d = li.index(num)
ans = (k-d)%(len(li)-d)+d
print((li[ans])) | p02684 |
import math
import queue
from collections import defaultdict
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChar():
return eval(input())
def readChars():
return input().split()
def factorization(n):
res = []
if n%2==0:
res.append(2)
for i in range(3,math.floor(n//2)+1,2):
if n%i==0:
c = 0
for j in res:
if i%j==0:
c=1
if c==0:
res.append(i)
return res
def fact2(n):
p = factorization(n)
res = []
for i in p:
c=0
z=n
while 1:
if z%i==0:
c+=1
z/=i
else:
break
res.append([i,c])
return res
def fact(n):#階乗
ans = 1
m=n
for _i in range(n-1):
ans*=m
m-=1
return ans
def comb(n,r):#コンビネーション
if n<r:
return 0
l = min(r,n-r)
m=n
u=1
for _i in range(l):
u*=m
m-=1
return u//fact(l)
def printQueue(q):
r=qb
ans=[0]*r.qsize()
for i in range(r.qsize()-1,-1,-1):
ans[i] = r.get()
print(ans)
def dq():
return queue.deque()
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x): # root
if self.parents[x]<0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y = y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self,x):
return -1*self.parents[self.find(x)]
def same(self,x,y):
return self.find(x)==self.find(y)
def members(self,x): # much time
root = self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()} # 1~n
def bitArr(n):#ビット全探索
x = 1
zero = "0"*n
ans = []
ans.append([0]*n)
for i in range(2**n-1):
ans.append(list([int(x) for x in list((zero+bin(x)[2:])[-1*n:])]))
x+=1
return ans;
def arrsSum(a1,a2):
for i in range(len(a1)):
a1[i]+=a2[i]
return a1
n,k = readInts()
a = readInts()
now = [1]
l = 1
while now.count(l)<2:
l = a[l-1]
now.append(l)
zen = now.index(now[-1])
kou = len(now)-zen
if k<zen:
print((now[k]))
else:
x = (k-zen)%(kou-1)
print((now[zen:][x])) | import math
import queue
from collections import defaultdict
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChar():
return eval(input())
def readChars():
return input().split()
def factorization(n):
res = []
if n%2==0:
res.append(2)
for i in range(3,math.floor(n//2)+1,2):
if n%i==0:
c = 0
for j in res:
if i%j==0:
c=1
if c==0:
res.append(i)
return res
def fact2(n):
p = factorization(n)
res = []
for i in p:
c=0
z=n
while 1:
if z%i==0:
c+=1
z/=i
else:
break
res.append([i,c])
return res
def fact(n):#階乗
ans = 1
m=n
for _i in range(n-1):
ans*=m
m-=1
return ans
def comb(n,r):#コンビネーション
if n<r:
return 0
l = min(r,n-r)
m=n
u=1
for _i in range(l):
u*=m
m-=1
return u//fact(l)
def printQueue(q):
r=qb
ans=[0]*r.qsize()
for i in range(r.qsize()-1,-1,-1):
ans[i] = r.get()
print(ans)
def dq():
return queue.deque()
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1]*n
def find(self, x): # root
if self.parents[x]<0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y = y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self,x):
return -1*self.parents[self.find(x)]
def same(self,x,y):
return self.find(x)==self.find(y)
def members(self,x): # much time
root = self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()} # 1~n
def bitArr(n):#ビット全探索
x = 1
zero = "0"*n
ans = []
ans.append([0]*n)
for i in range(2**n-1):
ans.append(list([int(x) for x in list((zero+bin(x)[2:])[-1*n:])]))
x+=1
return ans;
def arrsSum(a1,a2):
for i in range(len(a1)):
a1[i]+=a2[i]
return a1
n,k = readInts()
a = readInts()
now = [1]
check = [0]*n
check[0] = 1
l = 1
while check[l-1]<2:
l = a[l-1]
check[l-1]+=1
now.append(l)
zen = now.index(now[-1])
kou = len(now)-zen
if k<zen:
print((now[k]))
else:
x = (k-zen)%(kou-1)
print((now[zen:][x])) | p02684 |
# = int(input())
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# = [int(input()) for i in range(N)]
# = [list(map(int, input().split())) for i in range(N)]
next = 1
List = []
for i in range(K):
List.append(next)
next = A[next-1]
if len(set(List)) != len(List):
break
if len(set(List)) != len(List):
count = [i for i, x in enumerate(List) if x == List[-1]]
loop = count[1] - count[0]
afterloop = (K-count[0])%loop
print((List[count[0]+afterloop]))
else:
print(next)
| # = int(input())
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# = [int(input()) for i in range(N)]
# = [list(map(int, input().split())) for i in range(N)]
next = 1
List = [-1]*N
for i in range(K):
if List[next-1] == -1:
List[next-1] = i
next = A[next-1]
else:
loop = i - List[next-1]
afterloop = (K-(i-loop))%loop
print((List.index((i-loop) + afterloop)+1))
exit()
print(next)
| p02684 |
from collections import deque
n,k = list(map(int,input().split()))
tele = {}
a = list(map(int,input().split()))
for i in range(1,n+1):
tele[i] = a[i-1]
lis = deque([1])
now = 1
n = 1
while tele[now] not in lis:
lis.append(tele[now])
now = tele[now]
p = lis.index(tele[now])
q = len(lis) - p
if k <= p:
print((lis[k]))
else:
print((lis[(k-p)%q + p]))
| n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
l=[1]
di={}
di[1]=1
for i in a:
b=a[l[-1]-1]
if b in di:
x=b
break
l.append(b)
di[b]=1
t1=0
for j in l:
if j==x:
break
else:
t1+=1
t2=len(l)-t1
if k<=t1:
print((l[k]))
else:
aa=(k-t1)%t2
print((l[t1+aa])) | p02684 |
N,K = list(map(int, input().split()))
A = [*[int(x)-1 for x in input().split()]]
cnt = [0]*N
pre = 0
for _ in range(N*2):
cnt[pre] += 1
now = A[pre]
pre = now
one = 0
loops = 0
for c in cnt:
if c == 1: one += 1
elif c > 1: loops += 1
k = max(0, K-one) % loops + min(K, one)
pre = 0
for _ in range(k):
now = A[pre]
pre = now
ans = pre + 1
print(ans)
| N,K = list(map(int, input().split()))
A = [*[int(x)-1 for x in input().split()]]
cnt, pre = [0]*N, 0
for _ in range(N*2):
cnt[pre] += 1
pre = A[pre]
one, loops = 0, 0
for c in cnt:
if c == 1: one += 1
elif c > 1: loops += 1
k = max(0, K-one) % loops + min(K, one)
pre = 0
for _ in range(k): pre = A[pre]
print((pre + 1))
| p02684 |
N,K = list(map(int, input().split()))
A = [*[int(x)-1 for x in input().split()]]
pre = 0
index = [-1]*N
path_cnt = 0
for i in range(N):
if index[pre] >= 0:
break
else:
index[pre] = i
path_cnt += 1
pre = A[pre]
loops = path_cnt - index[pre]
one = path_cnt - loops
k = max(0, K-one) % loops + min(K, one)
pre = 0
for _ in range(k): pre = A[pre]
print((pre + 1))
| N,K = list(map(int, input().split()))
A = [*[int(x)-1 for x in input().split()]]
index = [-1]*N
pre, path_cnt = 0, 0
for i in range(N):
if index[pre] >= 0: break
else:
index[pre] = i
path_cnt += 1
pre = A[pre]
loops = path_cnt - index[pre]
one = index[pre]
k = max(0, K-one) % loops + min(K, one)
pre = 0
for _ in range(k): pre = A[pre]
print((pre + 1))
| p02684 |
N,K = list(map(int, input().split()))
A = [*[int(x)-1 for x in input().split()]]
index = [-1]*N
path = []
pre = 0
while index[pre] < 0:
index[pre] = len(path)
path += [pre]
pre = A[pre]
one = index[pre]
loops = len(path) - one
k = max(0, K-one) % loops + min(K, one)
pre = 0
for _ in range(k): pre = A[pre]
print((pre + 1))
# if K <= one: print(path[K])
# else: print(path[(K-one) % loops + one]+1)
| N,K = list(map(int, input().split()))
A = [*[int(x)-1 for x in input().split()]]
index = [-1]*N
path = []
pre = 0
while index[pre] < 0:
index[pre] = len(path)
path += [pre]
pre = A[pre]
one = index[pre]
loops = len(path) - one
if K < one: print((path[K]+1))
else: print((path[(K-one) % loops + one]+1))
| p02684 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
order = []
ans = A[0] - 1
start = 0
stop = 0
for i in range(K):
order.append(ans)
if len(set(order)) != i+1:
stop = i - 1
start = order.index(ans)
new = order[start:stop+1]
break
else:
if i == K - 1:
print((ans+1))
exit()
else:
ans = A[ans] - 1
print((new[(K-start) % (stop-start+1)-1]+1))
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
n = 1
order = [n]
order_set = set([n])
for i in range(1, K + 1):
n = A[n - 1]
if n in order_set:
Li = order.index(n)
Ri = len(order)
idx = Li + (K - Li) % (Ri - Li)
print((order[idx]))
exit()
else:
order.append(n)
order_set.add(n)
continue
print(n)
| p02684 |
from itertools import count
N, K = list(map(int, input().split()))
As = [int(n) for n in input().split()]
visited = []
now = 0
num = 0
idx = 0
for i in count():
if now in visited:
idx = visited.index(now)
num = len(visited) - idx
break
visited.append(now)
now = As[now] - 1
if K <= idx:
print((visited[K] + 1))
else:
print((visited[idx + (K - idx) % num] + 1)) | from itertools import count
N, K = list(map(int, input().split()))
As = [int(n) for n in input().split()]
visited = []
visited_set = set()
now = 0
num = 0
idx = 0
for i in count():
if now in visited_set:
idx = visited.index(now)
num = len(visited) - idx
break
visited_set.add(now)
visited.append(now)
now = As[now] - 1
if K <= idx:
print((visited[K] + 1))
else:
print((visited[idx + (K - idx) % num] + 1)) | p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
loop = 0
use = [0] * n
now = 0
use[now] = 1
x = [1]
for _ in range(n):
next = a[now] - 1
x.append(next+1)
if use[next] == 0:
use[next] = 1
now = next
else:
break
y = []
while x.count(x[0]) == 1:
tmp = x.pop(0)
y.append(tmp)
x.pop(-1)
if k < len(y):
kk = k % len(y)
print((y[kk]))
else:
k -= len(y)
kk = k % len(x)
print((x[kk]))
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
loop = 0
use = [0] * n
now = 0
use[now] = 1
x = [1]
for _ in range(n):
next = a[now] - 1
x.append(next+1)
if use[next] == 0:
use[next] = 1
now = next
else:
break
loop = x.pop(-1)
tmp = x.index(loop)
y = x[:tmp]
x = x[tmp:]
#print(y, x)
if k < len(y):
kk = k % len(y)
print((y[kk]))
else:
k -= len(y)
kk = k % len(x)
print((x[kk]))
| p02684 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
visited = [-1]*(N+1)
path = []
at = 1
count = 0
while True:
if visited[at] != -1:
loop = count-visited[at]
if K < count: # (K-visited[at])//loopが1以上であることを保証
print((path[K])) # 条件 K < visited[at]なら、(K-visited[at])//loopが0以上であることを保証。どっちでもよさそう。
else:
print((path[(K-visited[at])%loop+visited[at]]))
break
visited[at] = count
count += 1
path.append(at)
at = A[at-1] | n, k = list(map(int, input().split()))
q = list(map(int, input().split()))
v = [-1]*(n+1)
p = []
a = 1
c = 0
while 1:
if v[a] != -1:
l = c-v[a]
if k < c:
print((p[k]))
else:
print((p[(k-v[a])%l+v[a]]))
break
v[a] = c
c += 1
p.append(a)
a = q[a-1] | p02684 |
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [x-1 for x in A]
town = 0
cnt = 0
# memo = []
# visited = [False] * n
# visited[0] = -1
# start = 0
# loop = 10**8
# start_cnt = 0
# for i in range(n*2):
# town = A[town]
# memo.append(town)
# if visited[town] != False:
# start_cnt = i + 1
# loop = i - visited[town]
# break
# else:
# visited[town] = i
#
# for i in range((k-start_cnt)%loop):
# town = A[town]
#
# print(town+1)
visited = [False] * n
visited[0] = 0
for i in range(n):
town = A[town]
if visited[town]:
good_town = town
break
visited[town] = i+1
town = good_town
for i in range(n):
town = A[town]
if town == good_town:
loop = i + 1
if k >= visited[good_town]:
k = ((k-visited[good_town])%loop)+visited[good_town]
town = 0
for i in range(k):
town = A[town]
print((town+1)) | n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [x-1 for x in A]
town = 0
cnt = 0
visited = [False] * n
visited[0] = -1
start_cnt = 0
for i in range(n*2):
town = A[town]
if visited[town] != False:
start_cnt = i + 1
loop = i - visited[town]
break
else:
visited[town] = i
town = 0
if k >= start_cnt:
k = (k-start_cnt)%loop+start_cnt
for i in range(k):
town = A[town]
print((town+1))
| p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
now = 1
path = [now]
for i in range(k):
now = a[now-1]
if now in set(path):
now = path[path.index(now) + (k-i-1)%(len(path) - path.index(now))]
break
path.append(now)
print(now)
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
alr = [0 for i in range(n)]
now = 1
path = [now]
for i in range(k):
now = a[now-1]
# if now in path:
# now = path[path.index(now) + (k-i-1)%(len(path) - path.index(now))]
# break
if alr[now-1] != 0:
now = path[path.index(now) + (k-i-1)%(len(path) - path.index(now))]
break
path.append(now)
alr[now-1] += 1
print(now)
| p02684 |
N, K = list(map(int, input().split(" ")))
routs = {}
location = [0 for i in range(N + 1)]
tereporter = list(map(int, input().split()))
for i in range(N):
routs[i] = tereporter[i] - 1
present_location = 0
n = 0
for i in range(K):
n += 1
present_location = routs[present_location]
if location[present_location] == 0:
location[present_location] = n
else:
loop = n - location[present_location]
if (K - location[present_location]) % loop == 0:
break
else:
for i in range((K - location[present_location]) % loop):
present_location = routs[present_location]
break
print((present_location + 1)) | N, K = list(map(int, input().split()))
teleporters = list(map(int, input().split()))
n = 0
present = 0
praces = [-1 for i in range(N)]
praces[0] = 0
for i in range(K):
present = teleporters[present] - 1
n += 1
if praces[present] == -1:
praces[present] = n
else:
before = praces[present]
loop = n - before
remainder = (K - before) % loop
present = praces.index(before + remainder)
break
print((present + 1)) | p02684 |
N, K = list(map(int, input().split()))
teleporters = list(map(int, input().split()))
n = 0
present = 0
praces = [-1 for i in range(N)]
praces[0] = 0
for i in range(K):
present = teleporters[present] - 1
n += 1
if praces[present] == -1:
praces[present] = n
else:
before = praces[present]
loop = n - before
remainder = (K - before) % loop
present = praces.index(before + remainder)
break
print((present + 1)) | from sys import exit
n, K = list(map(int, input().split()))
A = list([int(x) - 1 for x in input().split()])
done = [-1 for _ in range(n)]
tmp = 0
done[0] = 0
for k in range(1, K + 1):
tmp = A[tmp]
if done[tmp] >= 0:
for i in range((K - done[tmp]) % (k - done[tmp])):
tmp = A[tmp]
print((tmp + 1))
exit()
else:
done[tmp] = k
print((tmp + 1))
| p02684 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
visitcount = dict()
n_point = list()
x = 1
count = 0
while(x not in set(visitcount)):
visitcount[x] = count
n_point.append(x)
x = A[x-1]
count += 1
period = count - visitcount[x]
if (K < visitcount[x]):
print((n_point[K]))
else:
y = (K-visitcount[x]) % period
print((n_point[visitcount[x] + y]))
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
visitset = set()
visitcount = dict()
n_point = dict()
x = 1
count = 0
while(x not in visitset):
visitset.add(x)
visitcount[x] = count
n_point[count] = x
x = A[x-1]
count += 1
period = count - visitcount[x]
if (K < visitcount[x]):
print((n_point[K]))
else:
y = (K-visitcount[x]) % period
print((n_point[visitcount[x] + y]))
| p02684 |
n,k,*a=list(map(int,open(0).read().split()))
d={}
s=1
while k:k-=1;s=a[s-1];k%=d.get(s,2**61)-k;d[s]=k
print(s) | n,k,*a=list(map(int,open(0).read().split()))
d=[2**61]*-~n
s=1
while k:k-=1;s=a[s-1];k%=d[s]-k;d[s]=k
print(s) | p02684 |
N, K = list(map(int, input().split()))
A = list([int(x) - 1 for x in input().split()])
R = []
done = set()
todo = [0]
done = set()
bp = None
while todo:
p = todo.pop()
R.append(p)
done.add(p)
np = A[p]
if np in done:
bp = np
else:
todo.append(np)
b = R.index(bp)
if K < b:
ans = R[K] + 1
else:
K -= b
R = R[b:]
ans = R[K%len(R)] + 1
print(ans) | N, K = list(map(int, input().split()))
A = tuple(int(x) - 1 for x in input().split())
done = {0}
rt = [0]
loop_point = 0
while True:
p = rt[-1]
np = A[p]
if np in done:
loop_point = np
break
done.add(np)
rt.append(np)
if K < len(rt):
ans = rt[K] + 1
else:
K -= len(rt)
rt = rt[rt.index(loop_point):]
ans = rt[K%len(rt)] + 1
print(ans) | p02684 |
N, K = list(map(int, input().split()))
where_go = list(map(int, input().split()))
now = 0
PATH = []
start = 0
roop = 0
count = 0
while now not in PATH and count < K:
PATH.append(now)
now = where_go[now] - 1
count += 1
if count < K:
start = PATH.index(now)
roop = len(PATH) - start
K = (K - start) % roop
count = 0
while count < K:
now = where_go[now] - 1
count += 1
print((now+1)) | N, K = list(map(int, input().split()))
A = list(map(int, input().split())) #どこに行くかのリスト
now = 0 #どこにいるか
LOG = {}
roop = 0
count = 0
while now not in LOG and count < K:
LOG.setdefault(now, count)
now = A[now] - 1
count += 1
if count < K:
roop = len(LOG) - LOG[now]
K = (K - count) % roop
count = 0
while count < K:
now = A[now] - 1
count += 1
print((now+1)) #行った場所を保存 | p02684 |
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
pl=1
visit=[1]
loop=0
q=True
v=True
cnt=0
br=False
while q:
cnt+=1
pl=a[pl-1]
for i in visit:
if pl==i:
loop=visit.index(pl)
br=not br
break
if br:
break
visit.append(pl)
if cnt==k:
print(pl)
v=not v
break
if cnt==10**7:
q=not q
if v:
loop_len=cnt-loop
q=True
k=(k-loop)%loop_len
cnt=0
if k==0:
print(pl)
else:
while q:
cnt+=1
pl=a[pl-1]
if cnt==k:
print(pl)
break
if cnt==10**7:
q=not q | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
pl=1
visit=[-1]*n
visit[0]=0
loop=0
q=True
v=True
cnt=0
while q:
cnt+=1
pl=a[pl-1]
if visit[pl-1]!=-1:
loop=visit[pl-1]
break
visit[pl-1]=cnt
if cnt==k:
print(pl)
v=not v
break
if cnt==10**7:
q=not q
if v:
loop_len=cnt-loop
q=True
k=(k-loop)%loop_len
cnt=0
if k==0:
print(pl)
else:
while q:
cnt+=1
pl=a[pl-1]
if cnt==k:
print(pl)
break
if cnt==10**7:
q=not q | p02684 |
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
pl=1
visit=[-1]*n
visit[0]=0
loop=0
q=True
v=True
cnt=0
while q:
cnt+=1
pl=a[pl-1]
if visit[pl-1]!=-1:
loop=visit[pl-1]
break
visit[pl-1]=cnt
if cnt==k:
print(pl)
v=not v
break
if cnt==10**7:
q=not q
if v:
loop_len=cnt-loop
q=True
k=(k-loop)%loop_len+loop
print((visit.index(k)+1)) | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
pl=1
visit=[-1]*n
visit[0]=0
loop=0
cnt=0
while 1:
cnt+=1
pl=a[pl-1]
if visit[pl-1]!=-1:
loop=visit[pl-1]
break
visit[pl-1]=cnt
if cnt==k:
print(pl)
exit()
loop_len=cnt-loop
q=True
k=(k-loop)%loop_len+loop
print((visit.index(k)+1)) | p02684 |
n, k = list(map(int, input().split()))
a = [0] + list(map(int,input().split()))
explored = [0] * (n+1)
t = 1
cycle = 0
while True:
if explored[t] == 2:
k %= cycle
explored[t] += 1
elif explored[t] == 1:
explored[t] += 1
cycle += 1
elif explored[t] == 0:
explored[t] += 1
k -= 1
if k == 0:
break
else:
t = a[t]
print((a[t])) | n, k = list(map(int, input().split()))
a = [0] + list(map(int,input().split()))
explored = [0] * (n+1)
t = 1
cycle = 0
while True:
if explored[t] == 2:
k %= cycle
if k == 0:
k = cycle
explored[t] += 1
elif explored[t] == 1:
explored[t] += 1
cycle += 1
elif explored[t] == 0:
explored[t] += 1
k -= 1
if k == 0:
break
else:
t = a[t]
print((a[t])) | p02684 |
n, k, *A = list(map(int, open(0).read().split()))
#n, k = map(int, input().split())
#A = [int(a) for a in input().split()]
Jump = [None] * n
Jump[0] = 1
next = 0
for i in range(1,n+1):
to = A[next]
if to in Jump:
start = Jump.index(to)
end = i
dis = end - start
roop = (k-start) % dis
print((Jump[start+roop]))
break
Jump[i] = to
next = to-1
if i ==k:
print(to)
break
| n, k = list(map(int, input().split()))
A = [int(a) for a in input().split()]
Jump = [None] * n
Jump[0] = 1
Rireki = [-1] * (n+1)
Rireki[0] = 0
next = 0
for i in range(1,n+1):
to = A[next]
if Rireki[to] >= 0:
start = Jump.index(to)
end = i
dis = end - start
roop = (k-start) % dis
print((Jump[start+roop]))
break
Rireki[to] = i
Jump[i] = to
next = to-1
if i ==k:
print(to)
break
| p02684 |
n,k = list(map(int,input().split()))
s = list(map(int,input().split()))
# print(s)
now_city = 1
s_l_city = 1
t = [1] #何回そこを通ったか
f = [0] #何回目にそこを通ったか
a=0
b = 0#サイクルありなし
f_l=0
for i in range(n-1):
t.append(0)
f.append(-1)
# print(s)
sycle = 0
for i in range(1,n+1):
now_city = s[now_city-1]
t[now_city-1]+=1
for j in range(n):
if t[j]==2:
# print(i,f[j])
sycle=i-f[j]
f_l=f[j]
a = 1
b = 1
s_l_city=j+1
break
if a==1:
break
f[now_city-1]=i
# print(t)
# print(f_l,sycle,s_l_city)
if b==1:
now_city=s_l_city
for j in range((k-f_l)%sycle):
now_city = s[now_city-1]
print(now_city)
else:
for j in range(k):
now_city=s[now_city]
print(now_city) | N, K = list(map(int, input().split()))
A = input().split()
A = [int(a) for a in A]
S = [1]
a = 1
number = 0
numbers=[-1 for _ in range(N)]
for _ in range(N + 1):
b = A[a - 1]
if numbers[b-1] != -1:
c=numbers[b-1] #1回目にループが現れた回数-1
# print("ループの最初の数字",b,"最初は"+str(c+1)+"回目","周期は",number-c)
break
numbers[b-1]=number
number += 1
S.append(b)
a = b
T = S[c+1:number+1]
if K <= number:
print((S[K ]))
else:
z = K - c-1
y = z % (number - c)
# print(y)
print((T[y])) | p02684 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 扱いやすいので1-indexedにする
A = [0] + A
# dp[2^k][i] はiから2^k回移動したときの移動先を表す
dp = {1: A}
for k in range(1, 100):
dp[2 ** k] = [0] # 先頭はダミー（1-indexedにするため）
for i in range(1, N + 1):
# jはiから2^{i - 1}回移動した先
j = dp[2 ** (k - 1)][i]
# iから2^k回移動した先 = jから2^{i - 1}回移動した先
dp[2 ** k].append(dp[2 ** (k - 1)][j])
ans = 1
for k in range(100):
if K & 2 ** k > 0:
ans = dp[2 ** k][ans]
K -= 2 ** k
print(ans)
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# 扱いやすいので1-indexedにする
A = [0] + A
# dp[k][i] はiから2^k回移動したときの移動先を表す
dp = [A]
for k in range(1, 100):
dp.append([0]) # 先頭はダミー（1-indexedにするため）
for i in range(1, N + 1):
# jはiから2^{i - 1}回移動した先
j = dp[k - 1][i]
# iから2^k回移動した先 = jから2^{i - 1}回移動した先
dp[k].append(dp[k - 1][j])
ans = 1
for k in range(100):
if K & 2 ** k > 0:
ans = dp[k][ans]
K -= 2 ** k
print(ans)
| p02684 |
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
ans =1
now = [1]
ed = set([1])
for i in range(n+1):
if a[now[i]-1] in ed:
break
now.append(a[now[i]-1])
ed = set(now)
t = len(now)-now.index(a[now[i]-1])
f = now.index(a[now[i]-1])
if k >= f + t:
p = (k-f)%t
k = f + p
print((now[k])) | import sys
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
visited = [None]*n
cur = 0
for i in range(k):
if visited[cur] is None:
visited[cur] = i
cur = a[cur]-1
else:
break
else:
print((cur+1))
sys.exit()
k -= i
k %= i-visited[cur]
for i in range(k):
cur = a[cur]-1
print((cur+1))
| p02684 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.