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.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.TreeSet;
 
 
 
public class Main {
  public static void main(String[] args) {
    InputReader sc = new InputReader(System.in);
 
    int n = sc.nextInt();
    int[] array1 = new int[n];
    int[] array2 = new int[n];
    for(int i = 0; i < n; i++){
      array1[i] = sc.nextInt();
    }
    for(int i = 0; i < n; i++){
      array2[i] = sc.nextInt();
    }
    int[] ansarray = new int[n];

    boolean noteasy = false;
    int index = 0;
    for(; index < n; index++){
      if(array1[index] == array2[n - index - 1]){
        noteasy = true;
        break;
      }else{
        ansarray[index] = array2[n - index - 1];
      }
    }
    boolean canclear = true;
    int ngnum = 0;
    if(noteasy){
      for(int i = n - 1; i >= index; i--){
        if(array1[i] == array2[i - index]){
          canclear = false;
          ngnum = array1[i];
          break;
        }else{
          ansarray[i] = array2[i - index];
        }
      }
    }

    boolean cancanclear = canclear;
    if(!cancanclear){
      int count1 = 0;
      int count2 = 0;
      for(int i = 0; i < n; i++){
        if(array1[i] == ngnum){count1++;}
        if(array2[i] == ngnum){count2++;}
      }
      if(count1 <= n - count2){cancanclear = true;}
      if(cancanclear){
        int index2 = 0;
        boolean[] usecheck = new boolean[n];
        for(int i = 0; i < n; i++){
          usecheck[i] = false;
        }
        for(int i = 0; i < n; i++){
          if(ngnum == array1[i]){
            while(array2[index2] == ngnum){
              index2++;
            }
            ansarray[i] = array2[index2];
            usecheck[index2] = true;
          }
        }
        index2 = n - 1;
        for(int i = 0; i < n; i++){
          if(ngnum != array1[i]){
            while(usecheck[index2]){
              index2--;
            }
            ansarray[i] = array2[index2];
          }
        }
      }
    }

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


  }
 
 //ここからテンプレ
  static class InputReader {
      private InputStream stream;
      private byte[] buf = new byte[1024];
      private int curChar;
      private int numChars;
      private SpaceCharFilter filter;
 
      public InputReader(InputStream stream) {
          this.stream = stream;
      }
 
      public int next() {
          if (numChars == -1)
              throw new InputMismatchException();
          if (curChar >= numChars) {
              curChar = 0;
              try {
                  numChars = stream.read(buf);
              } catch (IOException e) {
                  throw new InputMismatchException();
              }
              if (numChars <= 0)
                  return -1;
          }
          return buf[curChar++];
      }
 
      public String nextStr() {
        int c = next();
        while(isSpaceChar(c)){c = next();}
        StringBuffer str = new StringBuffer();
        do{
          str.append((char)c);
          c = next();
        }while(!isSpaceChar(c));
        return str.toString();
      }
 
      public char nextChar() {
        int c = next();
        while(isSpaceChar(c)){c = next();}
        char ret;
        do{
          ret = (char)c;
          c = next();
        }while(!isSpaceChar(c));
        return ret;
      }
 
      public int nextInt() {
          int c = next();
          while (isSpaceChar(c))
              c = next();
          int sgn = 1;
          if (c == '-') {
              sgn = -1;
              c = next();
          }
          int res = 0;
          do {
              if (c < '0' || c > '9')
                  throw new InputMismatchException();
              res *= 10;
              res += c - '0';
              c = next();
          } while (!isSpaceChar(c));
          return res * sgn;
      }
 
      public boolean isSpaceChar(int c) {
          if (filter != null)
              return filter.isSpaceChar(c);
          return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
      }
 
      public interface SpaceCharFilter {
          public boolean isSpaceChar(int ch);
      }
  }
}