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 C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <cassert>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>

using namespace std;
typedef long long ll;

struct Node {
  int val;
  int cntA;
  int cntB;

  Node(int val = -1, int cntA = -1, int cntB = -1) {
    this->val = val;
    this->cntA = cntA;
    this->cntB = cntB;
  }

  bool operator>(const Node &n) const {
    return cntA + cntB < n.cntA + n.cntB;
  }
};

int main() {
  int N;
  cin >> N;

  vector<int> A;
  vector<int> B;
  map<int, int> counterA;
  map<int, int> counterB;

  int a;
  for (int i = 0; i < N; ++i) {
    cin >> a;
    A.push_back(a);
    counterA[a]++;
  }

  int b;
  for (int i = 0; i < N; ++i) {
    cin >> b;
    B.push_back(b);
    counterB[b]++;
  }

  priority_queue <Node, vector<Node>, greater<Node>> pque;

  for (int i = 1; i <= N; ++i) {
    if (counterA[i] + counterB[i] > N) {
      cout << "No" << endl;
      return 0;
    }

    pque.push(Node(i, counterA[i], counterB[i]));
  }

  cout << "Yes" << endl;

  for (int i = 0; i < N; ++i) {
    Node node1 = pque.top();
    pque.pop();
    Node node2 = pque.top();
    pque.pop();

    if (node1.cntA > 0 && node2.cntB > 0) {
      cout << node2.val;

      node1.cntA--;
      node2.cntB--;
    } else if (node1.cntB > 0 && node2.cntA > 0) {
      cout << node1.val;

      node1.cntB--;
      node2.cntA--;
    }

    pque.push(node1);
    pque.push(node2);

    if (i == N - 1) {
      cout << endl;
    } else {
      cout << " ";
    }
  }

  return 0;
}