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 Java (OpenJDK 11.0.6) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());

		int[] a = new int[n];
		int[] b = new int[n];

		HashMap<Integer, Integer> count = new HashMap<Integer, Integer>();

		StringTokenizer st = new StringTokenizer(br.readLine(), " ");
		for (int i = 0; i < n; i++) {
			a[i] = Integer.parseInt(st.nextToken());
		}

		st = new StringTokenizer(br.readLine(), " ");
		for (int i = 0; i < n; i++) {
			b[i] = Integer.parseInt(st.nextToken());

			if (count.containsKey(b[i])) {
				count.put(b[i], count.get(b[i]) + 1);
			} else {
				count.put(b[i], 1);
			}
		}

		PriorityQueue<Integer> pq = new PriorityQueue<Integer>((o1, o2) -> count.get(o2) - count.get(o1));

		for (Integer key : count.keySet()) {
			pq.add(key);
		}

		boolean ok = true;

		for (int i = 0; i < n && ok; i++) {

			if (!pq.isEmpty()) {

				int b1 = pq.poll();

				if (b1 == a[i]) {
					if (pq.isEmpty()) {
						ok = false;
					} else {

						int b2 = pq.poll();

						if (count.get(b2) > 1) {
							count.put(b2, count.get(b2) - 1);
							pq.add(b2);
						}

						b[i] = b2;
						pq.add(b1);
					}
				} else {
					if (count.get(b1) > 1) {
						count.put(b1, count.get(b1) - 1);
						pq.add(b1);
					}
					b[i] = b1;
				}
			} else {
				ok = false;
			}
		}

		if (!ok) {
			System.out.println("No");
		} else {
			System.out.println("Yes");
			for (int i = 0; i < n - 1; i++) {
				System.out.print(b[i] + " ");
			}
			System.out.println(b[n - 1]);
		}
	}
}