Problem:
Score : 400 points

Problem Statement

#nck {
width: 30px;
height: auto;
}

You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:

1 \leq a_i, b_i \leq 10^9 for all i

a_1 < a_2 < ... < a_N

b_1 > b_2 > ... > b_N

a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}

Constraints

2 \leq N \leq 20,000

p is a permutation of the set {1, 2, ..., N}

Input

The input is given from Standard Input in the following format:

N
p_1 p_2 ... p_N

Output

The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.

It can be shown that there always exists a solution for any input satisfying the constraints.

Sample Input 1

2
1 2

Sample Output 1

1 4
5 4

a_1 + b_1 = 6 and a_2 + b_2 = 8. So this output satisfies all conditions.

Sample Input 2

3
3 2 1

Sample Output 2

1 2 3
5 3 1

Sample Input 3

3
2 3 1

Sample Output 3

5 10 100
100 10 1

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

#![allow(non_snake_case)]
#![allow(unused_variables)]

fn main() {
    let N: usize = {
        let mut line: String = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    };
    let p: Vec<usize> = {
        let mut line: String = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|x| x.parse().unwrap())
            .collect()
    };

    // 各インデックスの順位をもとにa, bの前項との差分を定める
    let q = p.iter()
        .enumerate()
        .map(|(i, &x)| (x - 1, i as i64))
        .collect::<std::collections::HashMap<_, _>>();
    let ans = {
        let mut a = vec![0; N];
        let mut b = vec![0; N];
        a[0] = 100_000_000;
        b[0] = 100_000_000;
        for i in 1..N {
            let d = q.get(&i).unwrap() - q.get(&(i - 1)).unwrap();
            a[i] = if d > 0 {
                a[i - 1] + d + 1
            } else {
                a[i - 1] + 1
            };
            b[i] = if d > 0 {
                b[i - 1] - 1
            } else {
                b[i - 1] + d - 1
            };
        }
        format!(
            "{}\n{}",
            a.iter()
                .map(std::string::ToString::to_string)
                .collect::<Vec<_>>()
                .join(" "),
            b.iter()
                .map(std::string::ToString::to_string)
                .collect::<Vec<_>>()
                .join(" ")
        )
    };

    println!("{}", ans);
}