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 C++ (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5+20 , INF = 0x3f3f3f3f;
int n,a[N],odd[N<<2],even[N<<2];
inline void update(int &x,int y) { if ( a[x] > a[y] ) x = y; }
inline void build(int p,int l,int r)
{
    if ( l == r )
        return ( ( l & 1 ) ? odd[p] = l : even[p] = l ) , void();
    int mid = l + r >> 1;
    build( p<<1 , l , mid ) , build( p<<1|1 , mid+1 , r );
    update( odd[p] , odd[p<<1] ) , update( odd[p] , odd[p<<1|1] );
    update( even[p] , even[p<<1] ) , update( even[p] , even[p<<1|1] );
}
inline int query(int p,int l,int r,int ql,int qr,int op)
{
    if ( ql <= l && qr >= r ) return op ? even[p] : odd[p];
    int mid = l + r >> 1 , res = 0;
    if ( ql <= mid ) update( res , query(p<<1,l,mid,ql,qr,op) );
    if ( qr > mid ) update( res , query(p<<1|1,mid+1,r,ql,qr,op) );
    return res;
}
struct sec
{
    int l,r,ansl,ansr,op;
    sec (int _l,int _r,int _op)
    {
        l = _l , r = _r , op = _op;
        ansl = query(1,1,n,l,r,op);
        ansr = query(1,1,n,ansl+1,r,op^1);
    }
    friend bool operator < (sec x,sec y)
    {
        if ( a[x.ansl] == a[y.ansl] )
            return a[x.ansr] < a[y.ansr];
        return a[x.ansl] < a[y.ansl];
    }
};
set <sec> S;
inline void solve(void)
{
    S.insert( sec(1,n,0) );
    while ( S.size() )
    {
        sec now = *S.begin(); S.erase(now);
        printf("%d %d ",a[now.ansl],a[now.ansr]);
        if ( now.l < now.ansl-1 )
            S.insert(sec(now.l,now.ansl-1,now.op));
        if ( now.ansl+1 < now.ansr-1 )
            S.insert(sec(now.ansl+1,now.ansr-1,now.op^1));
        if ( now.ansr+1 < now.r )
            S.insert(sec(now.ansr+1,now.r,now.op));
    }
}
inline void input(void)
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
        scanf("%d",&a[i]);
}
int main(void)
{
    input();
    a[0] = INF;
    build( 1 , 1 , n );
    solve();
    return puts("") , 0;
}