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 Kotlin (1.3.71) (judge verdict: Runtime Error)

private val readString: ()->String = {readLine()!!}
private val readInt: ()->Int = { readLine()!!.toInt() }
private val readLong: ()->Long = { readLine()!!.toLong() }
private val readListInt: ()->List<Int> = { readLine()!!.split(' ').map(String::toInt) }
private val readListLong: ()->List<Long> = { readLine()!!.split(' ').map(String::toLong) }
private val errPrintln: (String)->Unit = { msg -> System.err.println(msg) }
private const val MOD = 1_000_000_007L

var A = ArrayList<Int>()
var step = ArrayList<Long>()

fun solveD(N: Int, K: Long): Int {

    for (i in 0 until N) {
        step.add(-1L)
    }

    fun dfs(x: Int, sp:Long): Pair<Int, Long> {
        if (sp>=K) {
            return Pair(x, -1L);
        }

        if (step[x] >= 0L) {
            return Pair(x,sp)
        }

        step[x] = sp
        return dfs(A[x], sp + 1L)
    }

    var pos = dfs(0, 0L)
    if (pos.second < 0L) {
        return pos.first + 1;
    }

    errPrintln("pos: ${pos.first}")
    errPrintln("step[start]: ${step[pos.first]}")
    errPrintln("step[end]: ${pos.second}")

    val move = (K - step[pos.first]) % (pos.second - step[pos.first])
    errPrintln("move: $move")
    assert(move < K)

    fun dfs2(n: Long, x: Int): Int {
        if (n >= move) {
            return x
        }
        return dfs2(n + 1L, A[x])
    }

    return dfs2(0L, pos.first) + 1
}


fun main(args: Array<String>) {
    val (n,K) = readListLong()
    val N = n.toInt()
    val a = readListInt()

    for(i in 0 until N) {
        A.add(a[i] - 1)
    }

    val ans = solveD(N, K)

    println(ans)
}