Problem: We have a sequence of N \times K integers: X=(X_0,X_1,\cdots,X_{N \times K-1}). Its elements are represented by another sequence of N integers: A=(A_0,A_1,\cdots,A_{N-1}). For each pair i, j (0 \leq i \leq K-1,\ 0 \leq j \leq N-1), X_{i \times N + j}=A_j holds.  Snuke has an integer sequence s, which is initially empty. For each i=0,1,2,\cdots,N \times K-1, in this order, he will perform the following operation:    * If s does not contain X_i: add X_i to the end of s.   * If s does contain X_i: repeatedly delete the element at the end of s until s no longer contains X_i. Note that, in this case, we do **not** add X_i to the end of s.  Find the elements of s after Snuke finished the operations.

Submission attempts (in order):
import sys

def solve():
    input = sys.stdin.readline
    N, K = map(int, input().split())
    A = [int(a) for a in input().split()]

    numpos = dict()
    wordlist = [-1] * N
    for i in reversed(range(N)):
        if A[i] not in numpos:
            wordlist[i] = A[i]
            
        else:
            if numpos[A[i]] == N - 1: wordlist[i] = -1
            else: wordlist[i] = wordlist[numpos[A[i]] + 1]
        numpos[A[i]] = i

    #print(numpos)
    #print(wordlist)

    rem = [] 
    startindex = 0
    appeared = set()
    appeared_index = dict()
    rep_start = 0
    for i in range(K):
        remtop = wordlist[startindex]
        
        if remtop == -1: 
            rem.append(remtop)
            break
        elif remtop in appeared:
            rep_start = appeared_index[remtop]
            break
        else: 
            appeared |= {remtop}
            appeared_index[remtop] = i
            rem.append(remtop)
            startindex = (numpos[remtop] + 1) % N
        

    #print(rem)

    rep = len(rem) - rep_start
    ans = (K - rep_start) % rep
    ans -= 1
    #print(ans)
    if ans == -1: print("")
    else:
        if ans == 0: startindex = rep_start
        else: startindex = numpos[rem[rep_start + ans - 1]] + 1
        out = []
        using = dict()
        l = 0
        for i in range(startindex, N):
            if A[i] in using:
                aindex = using[A[i]]
                l = aindex
                for a in out[aindex:]:
                    using.pop(a)
                out = out[:aindex]
            else:
                out.append(A[i])
                using[A[i]] = l
                l += 1
            #print(out, using, l)
        print(" ".join(map(str, out)))


    return 0

if __name__ == "__main__":
    solve()


import sys

def solve():
    input = sys.stdin.readline
    N, K = map(int, input().split())
    A = [int(a) for a in input().split()]

    n_head_pos = dict() 
    rem_head_num = [-1] * N 
    for i in reversed(range(N)):
        if A[i] not in n_head_pos:
            rem_head_num[i] = A[i]
        else:
            if n_head_pos[A[i]] == N-1: rem_head_num[i] = -1
            else: rem_head_num[i] = rem_head_num[n_head_pos[A[i]] + 1]
        n_head_pos[A[i]] = i
    #print(n_head_pos)
    #print(rem_head_num)

    start_cycle = [] 
    start = -1
    used = set()
    while start not in used:
        used |= {start}
        start_cycle.append(start)
        if start == -1: next = rem_head_num[0]
        elif n_head_pos[start] < N - 1: next = rem_head_num[n_head_pos[start] + 1]
        else: next = -1
        start = next

    #print(start_cycle)

    len_cycle = len(start_cycle)
    last = (K - 1) % len_cycle 
    #print(last)
    if start_cycle[last] == -1: start_index = 0
    elif n_head_pos[start_cycle[last]] < N - 1: start_index =n_head_pos[start_cycle[last]] + 1
    else: start_index == -1
    #print(start_index)
    if start_index >= 0:
        out = []
        using = dict()
        l = 0
        for i in range(start_index, N):
            if A[i] in using:
                aindex = using[A[i]]
                l = aindex
                for a in out[aindex:]:
                    using.pop(a)
                out = out[:aindex]
            else:
                out.append(A[i])
                using[A[i]] = l
                l += 1
                #print(out, using, l)
        print(" ".join(map(str, out)))
    else: print(" ")

    return 0

if __name__ == "__main__":
    solve()

Verdicts: Wrong Answer

Accepted