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# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using static System.Math;
public static class P
{
    public static void Main()
    {
        int n = int.Parse(Console.ReadLine());
        var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
        var b = Console.ReadLine().Split().Select(int.Parse).ToArray();

        void Solve(int[] b)
        {
            if (b.Length != n) return;
            if (a.Zip(b).Any(x => x.First == x.Second)) return;

            Console.WriteLine("Yes");
            Console.WriteLine(string.Join(" ", b));
            Environment.Exit(0);
        }

        var s = Max(0, n / 2 - 10);
        for (int i = 0; i <= 20; i++)
        {
            Solve(b.Skip(s + i).Concat(b.Take(s + i)).ToArray());
        }

        int[] countsA = new int[n + 1];
        for (int i = 0; i < a.Length; i++)
            countsA[a[i]]++;

        int[] countsB = new int[n + 1];
        for (int i = 0; i < b.Length; i++)
            countsB[b[i]]++;

        var conb = countsA.Zip(countsB, Min).ToArray();
        var ind = Array.IndexOf(conb, conb.Max());

        var aInd = Array.IndexOf(a, ind);
        var bInd = Array.IndexOf(b, ind);

        var diff = Abs(bInd - aInd);
        if (aInd < bInd)
        {
            b = b.Skip(diff).Concat(b.Take(diff)).ToArray();
        }
        else
        {
            b = b.TakeLast(diff).Concat(b.SkipLast(diff)).ToArray();
        }

        for (int i = 0; i <= 20; i++)
        {
            Solve(b.Skip(s + i).Concat(b.Take(s + i)).ToArray());
        }

        

        Console.WriteLine("No");
    }
}