Problem:
Score : 600 points

Problem Statement

Given are two sequences A and B, both of length N.
A and B are each sorted in the ascending order.
Check if it is possible to reorder the terms of B so that for each i (1 \leq i \leq N) A_i \neq B_i holds, and if it is possible, output any of the reorderings that achieve it.

Constraints

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

1\leq A_i,B_i \leq N

A and B are each sorted in the ascending order.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Output

If there exist no reorderings that satisfy the condition, print No.

If there exists a reordering that satisfies the condition, print Yes on the first line.
After that, print a reordering of B on the second line, separating terms with a whitespace.

If there are multiple reorderings that satisfy the condition, you can print any of them.

Sample Input 1

6
1 1 1 2 2 3
1 1 1 2 2 3

Sample Output 1

Yes
2 2 3 1 1 1

Sample Input 2

3
1 1 2
1 1 3

Sample Output 2

No

Sample Input 3

4
1 1 2 3
1 2 3 3

Sample Output 3

Yes
3 3 1 2

Solution in Python (3.8.2) (judge verdict: Time Limit Exceeded)

# -*- coding: utf-8 -*-

from collections import Counter
from heapq import heappush, heappop

"""
 B  A B  A
    1 1
s=0 2 2 t=0
    3 3
"""

def solve():
    N = int(input())
    A = [-1]+list(map(int, input().split()))
    n_A = Counter(A)

    B = [-1]+list(map(int, input().split()))
    n_B = dict()
    for i,b in enumerate(B):
        n_B.setdefault(b,set()).add(i)
    if any(len(v) > N-n_A[k] for k,v in n_B.items()):
        return 'No'

    S = set(range(N+1))
    N_A = {k:S.difference(n_B.get(k,set())) for k in n_A}
    N_B = [0 for _ in range(N+1)]

    M = [0 for _ in range(N+1)]
    #q_B = set(range(N))
    q_B = {0}

    for i in range(1,N+1):
        if (q:=N_A[A[i]].difference(q_B)):
            j = q.pop()
            q_B.add(j)
            N_B[j] = i
            M[i] = j
            continue
        #print(' '.join(map(lambda x: '{:2d}'.format(B[x] if x != 's' else -1), M)))
        l_A = [N for _ in range(N+1)]
        p_A = [0 for _ in range(N+1)]
        p_B = [0 for _ in range(N+1)]
        hq = [(0, i)]
        while hq:
            #print(hq)
            l, j = heappop(hq)
            for b in N_A[A[j]]-{0}:
                a = N_B[b]
                if l_A[a] > l+1:
                    l_A[a] = l+1
                    p_A[a] = b
                    p_B[b] = j
                    heappush(hq, (l+1, a))
        P = [0]
        Q = []
        while 1:
            a = P[-1]
            b = p_A[a] 
            Q.append(b)
            if b == 0:
                break
            P.append(p_B[b])
            
        #print(P,Q)
        for a,b in zip(P[1:], Q[:-1]):
            #print(a,b)
            M[a] = b
            N_B[b] = a
            
            
        #print(P)
        

        #print(l_A)
        #print(p_A)
        #print(N_B)

    #print(' '.join(map(lambda x: '{:2d}'.format(A[x] if x != 's' else -1), range(1,N+1))))
    #print(' '.join(map(lambda x: '{:2d}'.format(B[x] if x != 's' else -1), M[1:])))
    


    return 'Yes\n' + ' '.join(f'{B[i]}' for i in M[1:])

if __name__ == '__main__':
    print(solve())