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
from collections import deque
from functools import lru_cache
import bisect
import copy
import heapq
import itertools
import math
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


def main():
    N = int(input())
    A = read_list()
    B = read_list()
    D = {}
    AC = {}
    BC = {}
    AI = {}
    for i, (a, b) in enumerate(zip(A, B)):
        AC[a] = AC.setdefault(a, 0) + 1
        BC[b] = BC.setdefault(b, 0) + 1
        D[a] = D.setdefault(a, 0) + 1
        D[b] = D.setdefault(b, 0) + 1
        if not a in AI:
            AI[a] = i

    E = sorted(list(D.items()), key=lambda i: (i[1], i[0]), reverse=True)
    # print(f"AI: {AI}")
    # print(f"AC: {AC}")
    # print(f"BC: {BC}")
    # print(f"E: {E}")
    if E[0][1] > N:
        print("No")
        return

    F = [-1] * N
    P = []
    j = 0
    for i, (k, _) in enumerate(E):
        if not k in BC:
            print(f"skip: i: {i}, k:{k}, P: {P}")
            P.append(k)
            continue
        
        v = BC[k]
        if k in AC and AC[k] > 0:
            P.append(k)
        # print(f"i: {i}, k:{k}, v: {v}, P: {P}")

        j = i + 1
        while v > 0 and j < len(E):
            l = E[j][0]
            # print(f"j: {j}, l: {l}")
            if not l in AC:
                j += 1
                continue
            li = AI[l] 
            t = min(AC[l], v)
            # print(f"l: {l}, li: {li}, t: {t}")
            for s in range(t):
                F[li + s] = k
            AI[l] += t
            AC[l] -= t
            v -= t
            j += 1

        while v > 0:
            p = P.pop()
            t = min(AC[p], v)
            li = AI[p]
            for s in range(t):
                F[li + s] = k
            AI[p] += t
            AC[p] -= t
            v -= t 
            if AC[p] > 0:
                P.append(p)

    print("Yes")
    print(" ".join(map(str, F)))
        

if __name__ == "__main__":
    main()