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 9.2.1) (judge verdict: Accepted)

#include <stdio.h>

#define SIZE 400
#define NUM 501

int main()
{
	int i, N, p[200001];
	scanf("%d", &N);
	for (i = 0; i < N; i++) scanf("%d", &(p[i]));
	
	int j, k = (N + SIZE - 1) / SIZE, min[2][NUM], argmin[2][NUM];
	for (i = 0; i < k; i++) {
		min[0][i] = p[i*SIZE];
		min[1][i] = p[i*SIZE+1];
		argmin[0][i] = i * SIZE;
		argmin[1][i] = i * SIZE + 1;
		for (j = i * SIZE + 2; j < N && j % SIZE != 0; j++) {
			if (p[j] < min[j%2][i]) {
				min[j%2][i] = p[j];
				argmin[j%2][i] = j;
			}
		}
	}
	
	int l, r, n, tmp, parity[NUM] = {}, flag[NUM] = {}, stop[200001] = {}, ans[200001];
	for (n = 0; n < N; n += 2) {
		for (i = 0, ans[n] = N + 1; i < k; i++) {
			if (min[0][i] < ans[n]) {
				ans[n] = min[0][i];
				l = argmin[0][i];
			}
		}
		for (j = l + 1, ans[n+1] = N + 1; j < N && j / SIZE == l / SIZE && stop[j-1] + stop[j] == 0; j += 2) {
			if (p[j] < ans[n+1]) {
				ans[n+1] = p[j];
				r = j;
			}
		}
		if (j < N && stop[j-1] + stop[j] == 0) {
			for (i = j / SIZE; i < k && flag[i] == 0; i++) {
				if (min[1][i] < ans[n+1]) {
					ans[n+1] = min[1][i];
					r = argmin[1][i];
				}
			}
			if (i < k) {
				for (j = i * SIZE + (l + 1) % 2; j < N && stop[j-1] + stop[j] == 0; j += 2) {
					if (p[j] < ans[n+1]) {
						ans[n+1] = p[j];
						r = j;
					}
				}
			}
		}
		
		stop[l] = 1;
		stop[r] = 1;
		i = l / SIZE;
		flag[i] = 1;
		for (j = i * SIZE, tmp = parity[i], min[0][i] = N + 1, min[1][i] = N + 1; j < N && j < (i + 1) * SIZE; j++) {
			if (stop[j] == 1) continue;
			if (p[j] < min[tmp][i]) {
				min[tmp][i] = p[j];
				argmin[tmp][i] = j;
			}
			tmp ^= 1;
		}
		if (r / SIZE > i) {
			for (i++; i < r / SIZE; i++) {
				parity[i] ^= 1;
				min[0][i] += min[1][i];
				min[1][i] = min[0][i] - min[1][i];
				min[0][i] -= min[1][i];
				argmin[0][i] += argmin[1][i];
				argmin[1][i] = argmin[0][i] - argmin[1][i];
				argmin[0][i] -= argmin[1][i];
			}
			flag[i] = 1;
			for (j = i * SIZE, parity[i] ^= 1, tmp = parity[i], min[0][i] = N + 1, min[1][i] = N + 1; j < N && j < (i + 1) * SIZE; j++) {
				if (stop[j] == 1) continue;
				if (p[j] < min[tmp][i]) {
					min[tmp][i] = p[j];
					argmin[tmp][i] = j;
				}
				tmp ^= 1;
			}
		}
	}
	
	for (i = 0; i < N - 1; i++) printf("%d ", ans[i]);
	printf("%d\n", ans[N-1]);
	fflush(stdout);
	return 0;
}