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

local read = setmetatable({}, {__index = function(t, k) local a = {} for i=1,#k do table.insert(a, '*'..string.sub(k, i, i)) end local r = io.read local u = table.unpack or unpack return function() return r(u(a)) end end})
read.N = function(N) local t={} for i=1,N do t[i]=read.n() end return t end
string.totable = function(s) local t={} local u=string.sub for i=1,#s do t[i] = u(s, i, i) end return t end
string.split = function(s) local t={} for w in string.gmatch(s, "[^%s]+") do table.insert(t, w) end return (table.unpack or unpack)(t) end
----
-- https://www.youtube.com/watch?v=nYFd7VHKyWQ
-- https://github.com/mission-peace/interview/blob/master/python/recursion/stringpermutation.py

-- For simplicity, this algorithm does not allow duplicate elements.

local function permute(seq)
    local inuse = {}
    local result = {}
    local function rec(level)
        if level > #seq then
            --print(table.concat(result, ""))
            coroutine.yield(result)
            return
        end
        for i=1,#seq do
            if not inuse[i] then
                result[level] = seq[i]
                inuse[i] = true
                rec(level + 1)
                inuse[i] = false
            end
        end
    end
    local function start()
        rec(1)
    end
    return coroutine.wrap(start)
end
----
-----
local N = read.n()
local A = {}
for i=1,N do
    A[i] = i
end
local function test()
    for k in permute(A) do
        print(table.concat(k,""))
    end
end
--test()
local P, Q = {}, {}
for i=1,N do
    P[i] = read.n()
end
for i=1,N do
    Q[i] = read.n()
end

local function sameseq(a, b)
    return table.concat(a, " ") == table.concat(b, " ")
end

local a, b
local i = 1
for k in permute(A) do
    if sameseq(k, P) then
        a = i
    end
    if sameseq(k, Q) then
        b = i
    end
    i = i + 1
end
print(math.abs(a-b))