Problem:
Score : 800 points

Problem Statement

Let N be a positive even number.

We have a permutation of (1, 2, ..., N), p = (p_1, p_2, ..., p_N).
Snuke is constructing another permutation of (1, 2, ..., N), q, following the procedure below.

First, let q be an empty sequence.
Then, perform the following operation until p becomes empty:

Select two adjacent elements in p, and call them x and y in order. Remove x and y from p (reducing the length of p by 2), and insert x and y, preserving the original order, at the beginning of q.

When p becomes empty, q will be a permutation of (1, 2, ..., N).

Find the lexicographically smallest permutation that can be obtained as q.

Constraints

N is an even number.

2 ≤ N ≤ 2 × 10^5

p is a permutation of (1, 2, ..., N).

Input

Input is given from Standard Input in the following format:

N
p_1 p_2 ... p_N

Output

Print the lexicographically smallest permutation, with spaces in between.

Sample Input 1

4
3 2 4 1

Sample Output 1

3 1 2 4

The solution above is obtained as follows:

p

q

(3, 2, 4, 1)

()

↓

↓

(3, 1)

(2, 4)

↓

↓

()

(3, 1, 2, 4)

Sample Input 2

2
1 2

Sample Output 2

1 2

Sample Input 3

8
4 6 3 2 8 5 7 1

Sample Output 3

3 1 2 7 4 6 8 5

The solution above is obtained as follows:

p

q

(4, 6, 3, 2, 8, 5, 7, 1)

()

↓

↓

(4, 6, 3, 2, 7, 1)

(8, 5)

↓

↓

(3, 2, 7, 1)

(4, 6, 8, 5)

↓

↓

(3, 1)

(2, 7, 4, 6, 8, 5)

↓

↓

()

(3, 1, 2, 7, 4, 6, 8, 5)

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
}

fn rec(p: &[usize]) -> Vec<(usize, usize)> {
    if p.len() < 2 {
        return Vec::new();
    }
    let mut pair = ((400000, 0), 0, 0);
    for i in 0..p.len() / 2 {
        let a = i * 2;
        for k in 0.. {
            let b = a + 1 + 2 * k;
            if b >= p.len() {
                break;
            }
            pair = min(pair, ((p[a], p[b]), a, b));
        }
    }
    let mut res = vec![(p[pair.1], p[pair.2])];
    let x1 = rec(&p[0..pair.1]);
    let x2 = rec(&p[pair.1 + 1..pair.2]);
    let x3 = rec(&p[pair.2 + 1..]);
    let l = 0..x1.len() + x2.len() + x3.len();

    let mut list = [x1, x2, x3];
    for _ in l {
        let y = {
            (0..3)
                .min_by_key(|&i| list[i].last().cloned().unwrap_or((400000, 0)))
                .unwrap()
        };
        res.push(list[y].pop().unwrap());
    }
    res.into_iter().rev().collect()
}

fn main() {
    let _n: usize = util::get();
    let p: Vec<usize> = util::gets();

    let a = rec(&p);

    println!(
        "{}",
        a.iter()
            .rev()
            .flat_map(|t| vec![t.0, t.1].into_iter())
            .map(|i| i.to_string())
            .collect::<Vec<_>>()
            .join(" ")
    );

}