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 Haskell (GHC 8.8.3) (judge verdict: Time Limit Exceeded)

import Control.Monad
import Data.Maybe
import qualified Data.ByteString.Char8 as BS
import Data.List
import Data.Ord
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM

readInt = fst . fromJust . BS.readInt
readIntList = map readInt . BS.words
getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine

main = do
    n <- getInt
    as <- getIntList
    bs <- getIntList
    let v = VU.create $ do
            vec <- VUM.replicate (n+1) (0 :: Int)
            forM_ as $ \i -> do
                VUM.modify vec succ i
            forM_ bs $ \i -> do
                VUM.modify vec succ i
            return vec
    let m = VU.maximum v
    let p = m > n
    let rs = solve ([],[]) as (reverse bs)
    if p then
        putStrLn "No"
    else do
        putStrLn "Yes"
        putStrLn $ unwords $ map show rs

solve (_,ans) [] [] = reverse ans
solve (l,ans) as [] = solve ([],ans) as (reverse l)
solve (l,ans) (a:as) (b:bs)
    | a /= b = solve (l,b:ans) as bs
    | a == b = solve (b:l,ans) (a:as) bs