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 Scala (2.13.1) (judge verdict: Runtime Error)

object Main extends App {
  val sc = new java.util.Scanner(System.in);
  val n = sc.nextInt();
  val as = Array.fill(n)(sc.nextInt);
  val bs = Array.fill(n)(sc.nextInt);
 
  val as_map = as.groupBy(x => x).map { case (k, v) => (k, v.size) }
  val bs_map = bs.groupBy(x => x).map { case (k, v) => (k, v.size) }
 
  val as_keys = as_map.keys.toArray.sorted;
  val bs_keys = bs_map.keys.toArray.sorted;
  val alen = as_keys.size;
  val blen = bs_keys.size;
 
  @scala.annotation.tailrec
  def sub(ia: Int, ib: Int): Boolean = {
    if (ia >= alen || ib >= blen) {
      true;
    } else {
      val a = as_keys(ia);
      val b = bs_keys(ib);
      if (a < b) {
        sub(ia + 1, ib);
      } else if (a > b) {
        sub(ia, ib + 1);
      } else {
        if (as_map(a) + bs_map(b) > n) {
          false;
        } else {
          sub(ia + 1, ib + 1);
        }
      }
    }
  }
  val flag = sub(0, 0);
  println(if(flag) "Yes" else "No");
  if (flag) {                                                                                                                                                                                                                                                   val as_map2 = (0 until n).foldLeft[Map[Int, List[Int]]](Map.empty) { (map, i) =>
      val k = as(i);
      val v = i;
      map.concat(List(k -> (v :: map.getOrElse(k, Nil))));
    }
 
    val b2 = bs_keys.sortBy(k => - (as_map(k) + bs_map(k)));
 
  val answer = Array.fill(n)(0);
  (0 until bs_keys.size).foreach { i =>
    val k = b2(i);
    val b_count = bs_map(k);
    var count: Int = 0;
    var j: Int = i + 1;
    if (j == bs_keys.size) {
      j = 0;
    }
    while (count < b_count) {
      val k2 = b2(j);
      as_map2(k2).foreach { idx =>
        if (count < b_count && answer(idx) == 0) {
          answer(idx) = k;
          count = count + 1;
        }
      }
      j = j + 1;
      if (j == bs_keys.size) {
        j = 0;
      }
    }
  }
 
  println(answer.mkString(" "));
  }
}