Problem:
Score: 400 points

Problem Statement

The Kingdom of Takahashi has N towns, numbered 1 through N.

There is one teleporter in each town. The teleporter in Town i (1 \leq i \leq N) sends you to Town A_i.

Takahashi, the king, loves the positive integer K. The selfish king wonders what town he will be in if he starts at Town 1 and uses a teleporter exactly K times from there.

Help the king by writing a program that answers this question.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq A_i \leq N

1 \leq K \leq 10^{18}

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \dots A_N

Output

Print the integer representing the town the king will be in if he starts at Town 1 and uses a teleporter exactly K times from there.

Sample Input 1

4 5
3 2 4 1

Sample Output 1

4

If we start at Town 1 and use the teleporter 5 times, our travel will be as follows: 1 \to 3 \to 4 \to 1 \to 3 \to 4.

Sample Input 2

6 727202214173249351
6 5 2 5 3 2

Sample Output 2

2

Solution in Go (1.14.1) (judge verdict: Accepted)

package main

import (
	"fmt"
	"math/big"
	"strconv"
)

var N int
var Kstr string
var K = big.NewInt(0)
var cycleStartAt, cycleStart int
var cycle []int

func main() {
	fmt.Scan(&N, &Kstr)
	ctr := int64(0)
	ten := big.NewInt(10)
	for i := len(Kstr) - 1; i >= 0; i-- {
		val, _ := strconv.Atoi(string(Kstr[i]))
		K = new(big.Int).Add(K, new(big.Int).Mul(big.NewInt(int64(val)), new(big.Int).Exp(ten, big.NewInt(ctr), nil)))
		ctr++
	}
	towns := make([]*town, N+1)
	towns[0] = &town{
		next: 1,
		came: false,
	}
	for i := 1; i <= N; i++ {
		var next int
		fmt.Scan(&next)
		towns[i] = &town{
			next: next,
			came: false,
		}
	}
	s := 1
	cur := 1
	for {
		if towns[cur].came {
			cycleStartAt = cur
			cycleStart = s
			break
		}
		towns[cur].came = true
		cur = towns[cur].next
		s++
	}
	cur = 0
	for i := 0; i <= N; i++ {
		if towns[cur].next == cycleStartAt {
			t := towns[cur]
			for {
				cycle = append(cycle, t.next)
				t = towns[t.next]
				if t.next == cycleStartAt {
					break
				}
			}
			break
		}
		cur = towns[cur].next
	}
	step := big.NewInt(0)
	cur = 1
	if K.Int64() <= int64(cycleStart) {
		for i := int64(1); i <= K.Int64(); i++ {
			cur = towns[cur].next
		}
		fmt.Println(cur)
		return
	}
	for {
		step = new(big.Int).Add(step, big.NewInt(1))
		currentTown := towns[cur]
		if currentTown.next == cycleStartAt {
			addr := new(big.Int).Mod(new(big.Int).Sub(K, step), big.NewInt(int64(len(cycle))))
			fmt.Print(cycle[addr.Int64()])
			return
		}
		cur = currentTown.next
	}
}

type town struct {
	next int
	came bool
}