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)

use proconio::*;
use proconio::marker::Usize1;
use std::collections::BinaryHeap;

fn my_pop(heap: &mut BinaryHeap<(usize, usize, usize)>, charge: &mut [usize]) -> Option<(usize, usize, usize)> {
    while let Some(x) = heap.pop() {
        if charge[x.2] > 0 {
            heap.push((x.0 - charge[x.2], x.1, x.2));
            charge[x.2] = 0;
        }
        else {
            return Some(x);
        }
    }

    None
}

fn solve() -> Option<Vec<usize>> {
    input!{
        n: usize,
        a: [Usize1; n],
        b: [Usize1; n],
    }

    let mut cnt_a = vec![0usize; n];
    let mut cnt_b = vec![0usize; n];

    for i in 0..n {
        cnt_a[a[i]] += 1;
        cnt_b[b[i]] += 1;
    }

    // let mut max_a = 0;
    // let mut max_b = 0;
    // for i in 0..n {
    //     max_a = max_a.max(cnt_a[i]);
    //     max_b = max_b.max(cnt_b[i]);
    // }

    // if n-max_a < max_b {
    //     println!("No");
    //     return;
    // }

    let mut heap = BinaryHeap::new();
    for i in 0..n {
        if cnt_b[i] == 0 {
            continue;
        }
        heap.push((cnt_a[i], cnt_b[i], i));
    }

    let mut charge = vec![0; n];
    let mut ans = Vec::new();
    for i in 0..n {
        // println!("{:?}", ans);
        // println!("{}", i);
        let tmp = my_pop(&mut heap, &mut charge);
        if tmp.is_none() {
            return None;
        }
        let tmp = tmp.unwrap();
        // println!("{:?}", tmp);
        if a[i] == tmp.2 {
            let tmp2 = my_pop(&mut heap, &mut charge);
            if tmp2.is_none() {
                return None;
            }
            let tmp2 = tmp2.unwrap();
            ans.push(tmp2.2);
            if tmp2.1 != 1 {
                heap.push((tmp2.0, tmp2.1-1, tmp2.2));
            }
            heap.push(tmp);
        }
        else {
            ans.push(tmp.2);
            if tmp.1 != 1 {
                heap.push((tmp.0, tmp.1-1, tmp.2));
            }
        }
        charge[a[i]] += 1;
    }

    Some(ans)

    
}

fn main() {
    if let Some(ans) = solve() {
        println!("Yes");
        for i in 0..ans.len() {
            if i > 0 {
                print!(" ");
            }
            print!("{}", ans[i]+1);
        }
        println!("");
    }
    else {
        println!("No");
    }
}