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 1.8.0) (judge verdict: Wrong Answer)

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    static class Pair {
    	int a, b;

		public Pair(int a, int b) {
			this.a = a;
			this.b = b;
		}
    }
	public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        
        int N = sc.nextInt();
        HashMap<Integer, Integer> A = new HashMap<>();
        HashMap<Integer, Integer> B = new HashMap<>();
        for(int i=0; i<N; i++) {
        	int a = sc.nextInt();
        	int b = sc.nextInt();

        	Integer aCount = A.get(a);
        	if(aCount == null)
        		aCount = 0;
        	A.put(a, aCount+1);

        	Integer bCount = B.get(b);
        	if(bCount == null)
        		bCount = 0;
        	B.put(b, bCount+1);

        }
        
        
        LinkedList<Pair> aUsed = new LinkedList<>();
        LinkedList<Pair> bUsed = new LinkedList<>();
        LinkedList<Pair> abUsed = new LinkedList<>();
        int notUsed = N;
        for(int i=1; i<=N; i++) {
        	Integer aCount = A.get(i);
        	if(aCount==null)
        		aCount = 0;
        	for(int j=0; j<aCount; j++) {
        		if(notUsed>0) {
        			aUsed.add(new Pair(i, -1));
        			notUsed--;
        		} else {
        			Pair p = bUsed.poll();
        			if(p.b==i) {
        				System.out.println("No");
        				sc.close();
        				pw.close();
        				return;
        			}
        			p.a = i;
        			abUsed.add(p);
        		}
        	}
        	
        	Integer bCount = B.get(i);
        	if(bCount==null)
        		bCount = 0;
        	for(int j=0; j<bCount; j++) {
        		if(notUsed>0) {
        			bUsed.add(new Pair(-1, i));
        			notUsed--;
        		} else {
        			Pair p = aUsed.poll();
        			if(p.a==i) {
        				System.out.println("No");
        				sc.close();
        				pw.close();
        				return;
        			}
        			p.b = i;
        			abUsed.add(p);
        		}
        	}
         	
        }
        ArrayList<Pair> sorted = new ArrayList<>();
        sorted.addAll(abUsed);
        sorted.sort(new Comparator<Pair>() {
        	public int compare(Pair p1, Pair p2) {
        		return Integer.compare(p1.a, p2.a);
        	}
        });
        
        pw.println("Yes");
        for(int i=0; i<N; i++)
        	pw.print(sorted.get(i).b + (i==N-1 ? "\n" : " "));
        
        System.out.println();
        sc.close();
        pw.close();
	}
}