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: Runtime Error)

// Powered by caibiCH2 at 2020/09/13,20:58:29
#include <bits/stdc++.h>
#define elif else if
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
int a[201000], b[201000];
vector<int> bdata[201000], ans[201000];
int num[201000], anum[201000], bnum[201000];
signed main() {
    ios::sync_with_stdio(0);
    // cin.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        ++anum[a[i]];
        ++num[a[i]];
    }
    for (int i = 1; i <= n; ++i) {
        cin >> b[i];
        ++bnum[b[i]];
        ++num[b[i]];
    }
    // sort(b + 1, b + n + 1, [](int x, int y) { return bnum[x] > bnum[y]; });
    for (int i = 1; i <= n; ++i)
        if (num[i] > n) {
            cout << "No\n";
            return 0;
        }
    cout << "Yes\n";
    for (int i = 1; i <= n; ++i) bdata[bnum[i]].pb(i);
    struct msp {
        int x, tms;
        bool operator<(const msp& y) const { return tms < y.tms; }
    };

    priority_queue<msp> q;

    for (int i = 1; i <= n; ++i)
        if (anum[i]) q.push({i, num[i]});
    // while (q.size()) {
    //     cerr << q.top().tms << '\n';
    //     q.pop();
    // }
    // for (int i = 1; i <= n; ++i)
    //     if (anum[i]) q.push({i, num[i]});

    for (int i = n; i >= 1; --i) {
        while (bdata[i].size()) {
            // cerr << q.size() << endl;
            auto nowx = q.top();
            q.pop();
            int x = bdata[i].back();
            bdata[i].pop_back();

            // cerr << x << ' ' << nowx.x << endl;
            if (nowx.x == x) {
                auto nowy = q.top();
                q.pop();
                // cerr << nowy.x << endl;
                q.push(nowx);
                nowx = nowy;
            }
            // cerr << x << ' ' << nowx.x << endl;
            ans[nowx.x].pb(x);
            --nowx.tms;
            --anum[nowx.x];
            if (anum[nowx.x]) q.push(nowx);
            bdata[i - 1].pb(x);
            // if (anum[data[i].back()]) {}
        }
    }
    for (int i = 1; i <= n; ++i) {
        for (auto t : ans[i]) cout << t << ' ';
    }
    return 0;
}