Problem:
Score : 300 points

Problem Statement

We have two permutations P and Q of size N (that is, P and Q are both rearrangements of (1,~2,~...,~N)).

There are N! possible permutations of size N. Among them, let P and Q be the a-th and b-th lexicographically smallest permutations, respectively. Find |a - b|.

Notes

For two sequences X and Y, X is said to be lexicographically smaller than Y if and only if there exists an integer k such that X_i = Y_i~(1 \leq i < k) and X_k < Y_k.

Constraints

2 \leq N \leq 8

P and Q are permutations of size N.

Input

Input is given from Standard Input in the following format:

N
P_1 P_2 ... P_N
Q_1 Q_2 ... Q_N

Output

Print |a - b|.

Sample Input 1

3
1 3 2
3 1 2

Sample Output 1

3

There are 6 permutations of size 3: (1,~2,~3), (1,~3,~2), (2,~1,~3), (2,~3,~1), (3,~1,~2), and (3,~2,~1). Among them, (1,~3,~2) and (3,~1,~2) come 2-nd and 5-th in lexicographical order, so the answer is |2 - 5| = 3.

Sample Input 2

8
7 3 5 4 2 1 6 8
3 8 2 5 4 6 7 1

Sample Output 2

17517

Sample Input 3

3
1 2 3
1 2 3

Sample Output 3

0

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[doc = " Ported from [bluss/permutohedron](https://github.com/bluss/permutohedron)"]
pub trait LexicalPermutation {
#[doc = " Return \'true\' if the slice was permuted, \'false\' if it is already "]
#[doc = " at the last ordered permutation."]
    fn next_permutation(&mut self) -> bool;
#[doc = " Return \'true\' if the slice was permuted, \'false\' if it is already "]
#[doc = " at the first ordered permutation."]
    fn prev_permutation(&mut self) -> bool;
}
impl<T> LexicalPermutation for [T]
where
    T: Ord,
{
#[doc = " Original author in Rust: Thomas Backman <serenity@exscape.org>"]
    fn next_permutation(&mut self) -> bool {
        if self.len() < 2 {
            return false;
        }
        let mut i = self.len() - 1;
        while i > 0 && self[i - 1] >= self[i] {
            i -= 1;
        }
        if i == 0 {
            return false;
        }
        let mut j = self.len() - 1;
        while j >= i && self[j] <= self[i - 1] {
            j -= 1;
        }
        self.swap(j, i - 1);
        self[i..].reverse();
        true
    }
#[doc = " Original author in Rust: Thomas Backman <serenity@exscape.org>"]
    fn prev_permutation(&mut self) -> bool {
        if self.len() < 2 {
            return false;
        }
        let mut i = self.len() - 1;
        while i > 0 && self[i - 1] <= self[i] {
            i -= 1;
        }
        if i == 0 {
            return false;
        }
        self[i..].reverse();
        let mut j = self.len() - 1;
        while j >= i && self[j - 1] < self[i - 1] {
            j -= 1;
        }
        self.swap(i - 1, j);
        true
    }
}

fn get_line() -> String {
    let mut line = String::new();
    std::io::stdin().read_line(&mut line).unwrap();
    line.trim().to_string()
}

fn main() {
    let n = get_line().parse::<usize>().unwrap();
    let p = get_line().split_whitespace()
        .map(|n| n.parse().unwrap())
        .collect::<Vec<usize>>();
    let q = get_line().split_whitespace()
        .map(|n| n.parse().unwrap())
        .collect::<Vec<usize>>();

    let mut v = (1..n + 1).collect::<Vec<usize>>();
    let (mut a, mut b): (i64, i64) = (0, 0);
    let mut count = 0;
    loop {
        if &v == &p { a = count; }
        if &v == &q { b = count; }
        if !v.next_permutation() { break; }
        count += 1;
    }
    println!("{}", (a - b).abs());
}