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: Accepted)

// -*- coding:utf-8-unix -*-

use proconio::{fastout, input};
use std::collections::{BTreeMap, BTreeSet, BinaryHeap};

#[fastout]
fn main() {
    input! {
        n: usize,
        a: [usize; n],
        b: [usize; n]
    }
    // Check the total numbers
    let mut a_occurrences: Vec<Vec<usize>> = vec![Vec::new(); n];
    let mut b_occurrences: Vec<Vec<usize>> = vec![Vec::new(); n];
    for i in 1..=n {
        a_occurrences[a[i - 1] - 1].push(i);
    }
    for i in 1..=n {
        b_occurrences[b[i - 1] - 1].push(i);
    }
    for j in 1..=n {
        if a_occurrences[j - 1].len() + b_occurrences[j - 1].len() > n {
            println!("No");
            return;
        }
    }
    // Generate the result
    let mut resulting_b = vec![0; n];
    let mut a_unpaired = BinaryHeap::new();
    let mut b_unpaired = BinaryHeap::new();
    for j in 1..=n {
        if a_occurrences[j - 1].is_empty() {
            continue;
        }
        a_unpaired.push((
            a_occurrences[j - 1].len(),
            a_occurrences[j - 1].len() + b_occurrences[j - 1].len(),
            j,
        ));
    }
    for j in 1..=n {
        if b_occurrences[j - 1].is_empty() {
            continue;
        }
        b_unpaired.push((
            b_occurrences[j - 1].len(),
            a_occurrences[j - 1].len() + b_occurrences[j - 1].len(),
            j,
        ));
    }
    while let Some((num1, _, j1)) = a_unpaired.pop() {
        let (mut num2, _, mut j2) = b_unpaired.pop().unwrap();
        if j1 == j2 {
            let (num3, _, j3) = b_unpaired.pop().unwrap();
            b_unpaired.push((
                num2,
                a_occurrences[j2 - 1].len() + b_occurrences[j2 - 1].len(),
                j2,
            ));
            num2 = num3;
            j2 = j3;
        }
        let i1 = a_occurrences[j1 - 1].pop().unwrap();
        let _i2 = b_occurrences[j2 - 1].pop().unwrap();
        resulting_b[i1 - 1] = j2;
        if num1 > 1 {
            a_unpaired.push((
                num1 - 1,
                a_occurrences[j1 - 1].len() + b_occurrences[j1 - 1].len(),
                j1,
            ));
        }
        if num2 > 1 {
            b_unpaired.push((
                num2 - 1,
                a_occurrences[j2 - 1].len() + b_occurrences[j2 - 1].len(),
                j2,
            ));
        }
    }
    println!("Yes");
    print!("{}", resulting_b[0]);
    for i in 2..=n {
        print!(" {}", resulting_b[i - 1]);
    }
    println!();
}