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 Kotlin (1.3.71) (judge verdict: Wrong Answer)

fun main() {
    val n = readInt()
    val a = readInts()
    val b = readInts()

    val occA = mutableListOf<Occurrences>()
    val occB = mutableListOf<Occurrences>()

    fun fillOcc(arr: List<Int>, occArr: MutableList<Occurrences>, index: Int) {
        if (occArr.isEmpty() || occArr.last().number != arr[index]) occArr.add(Occurrences(index, arr[index], 0))
        occArr.last().occ++
    }

    for (i in 0 until n) {
        fillOcc(a, occA, i)
        fillOcc(b, occB, i)
    }

    occA.sortBy { it.occ }
    occB.sortBy { it.occ }

    var aIndex = occA.size - 1
    var bIndex = if (occB[occB.size - 1].number == occA[aIndex].number) occB.size - 2 else occB.size - 1
    if (bIndex < 0) {
        println("No")
        return
    }
    val seenA = mutableSetOf<Int>()
    val seenB = mutableSetOf<Int>()

    val reordering = IntArray(n)
    while (seenA.size < occA.size && seenB.size < occB.size) {
        val currA = occA[aIndex]
        val currB = occB[bIndex]
        reordering[currA.startIndex] = currB.number
        currA.startIndex++
        currA.occ--
        currB.startIndex++
        currB.occ--
        if (currA.occ == 0) {
            seenA.add(aIndex)
            aIndex = (aIndex + occA.size - 1) % occA.size
        }

        if (currB.occ == 0) {
            seenB.add(bIndex)
            bIndex = (bIndex + occB.size - 1) % occB.size
        }
    }

    var good = true
    for (i in a.indices) good = good && (a[i] != reordering[i])
    if (!good) println("No")
    else {
        println("Yes")
        println(reordering.joinToString(" "))
    }
}

data class Occurrences(var startIndex: Int, val number: Int, var occ: Int)

// Input Reader
private fun readLn() = readLine()!!

private fun readStrings() = readLn().trim().split(" ")
private fun readInt() = readLn().toInt()
private fun readInts() = readStrings().map { it.toInt() }