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 Rust (1.42.0) (judge verdict: Time Limit Exceeded)

use proconio::input;
use proconio::marker::Usize1;
use proconio::marker::Chars;

#[proconio::fastout]
fn main() {
    input! {
        n: usize,
        a: [usize; n],
        b: [usize; n]
    }
    let mut count_a = vec![0; n+1];
    let mut count_b = vec![0; n+1];
    for i in 0..n {
        count_a[a[i]] += 1;
        count_b[b[i]] += 1;
    }
    for i in 1..=n {
        if count_a[i] + count_b[i] > n {
            println!("No");
            return;
        }
    }
    let mut lst_a = Vec::new();
    let mut lst_b = Vec::new();
    for i in 1..=n {
        if count_b[i] > 0 {
            lst_b.push((i, count_b[i]));
        }
    }
    for i in 0..n {
        lst_a.push((a[i], i));
    }
    lst_b.sort_by_key(|&x| x.1);
    let mut que_a = std::collections::VecDeque::new();
    for &x in lst_a.iter() {
        que_a.push_back((x.0, x.1));
    }
    let mut ans = vec![0; n];
    let mut count = 0;
    for &(v, num) in lst_b.iter() {
        let mut num = num;
        while num > 0 {
            let (v2, ind) = que_a.pop_front().unwrap();
            if v == v2 {
                que_a.push_back((v2, ind));
                continue;
            }
            count += 1;
            if count >= 10000000 {
                println!("No");
                return;
            }
            num -= 1;
            ans[ind] = v;
        }
    }
    println!("Yes");
    println!("{}", str_join(&ans));
}

fn str_join<T: std::string::ToString>(s: &Vec<T>) -> String {
    s.iter()
        .map(|i| i.to_string())
        .collect::<Vec<_>>()
        .join(" ")
}