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 PyPy3 (7.3.0) (judge verdict: Runtime Error)

#

import sys
input=sys.stdin.readline
import heapq

def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))
    cntA = dict()
    cntB = dict()
    for i in range(N):
        cntA[A[i]] = cntA.get(A[i], 0) + 1
        cntB[B[i]] = cntB.get(B[i], 0) + 1
    for i in range(1, N + 1):
        if cntA.get(i, 0) + cntB.get(i, 0) > N:
            print("No")
            exit()
    print("Yes")
    
    # cAcs = [0] * (N + 1)
    # for i in range(1, N + 1):
    #     cAcs[i] = cAcs[i - 1] + cntA.get(i, 0)
   
    # aaaa = sorted(cntB.items(), key = lambda x: x[1], reverse = True)
    # Bs = []
    # for k, v in aaaa:
    #     for i in range(v):
    #         Bs.append(k)

    # ans = [-1] * N
    # B = list(map(lambda x: -x, B))
    # heapq.heapify(B)
    # for i in range(N):
    #     wait = []
    #     while(ans[i] == -1):
    #         x = heapq.heappop(B)
    #         x = -x
    #         if A[i] == x:
    #             wait.append(-x)
    #         else:
    #             ans[i] = x
    #     for w in wait:
    #         heapq.heappush(B, w)
    # ans = list(map(str, ans))
    # print(" ".join(ans))
    
    ans = [-1] * N
    cntB2 = []
    for k, v in cntB.items():
        cntB2.append((-v, -v, k))
    heapq.heapify(cntB2)
    for i in range(N):
        vvo, vv, kk = heapq.heappop(cntB2)
        if kk == A[i]:
            vvvo, vvv, kkk = heapq.heappop(cntB2)
            ans[i] = kkk
            vvv += 1
            if vvv != 0:
                heapq.heappush(cntB2, (vvvo, vvv, kkk))
            heapq.heappush(cntB2, (vvo, vv, kk))
        else:
            ans[i] = kk
            vv += 1
            if vv != 0:
                heapq.heappush(cntB2, (vvo, vv, kk))
    ans = list(map(str, ans))
    print(" ".join(ans))
        
    
    
    
if __name__=="__main__":
    main()