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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

module Main where

-- import Debug.Trace

{-
 - Next lexicographical permutation algorithm
 - by Project Nayuki, 2016. Public domain.
 - https://www.nayuki.io/page/next-lexicographical-permutation-algorithm
 -
 - Computes the next lexicographical permutation of the specified finite list of numbers.
 - Returns Nothing if the argument is already the highest permutation.
 -}
nextPermutation :: Ord a => [a] -> Maybe [a]
nextPermutation xs =
  let
    len = length xs
    revSuffix = findPrefix (reverse xs)  -- Reverse of longest non-increasing suffix
    suffixLen = length revSuffix
    prefixMinusPivot = take (len - suffixLen - 1) xs
    pivot = xs !! (len - suffixLen - 1)
    suffixHead = takeWhile (<= pivot) revSuffix
    newPivot : suffixTail = drop (length suffixHead) revSuffix
    newSuffix = suffixHead ++ (pivot : suffixTail)
  in
    if suffixLen == len then Nothing else Just (prefixMinusPivot ++ (newPivot : newSuffix))
  where
    findPrefix [] = []
    findPrefix (x:xs) = x : (if xs /= [] && x <= (head xs) then (findPrefix xs) else [])

-- debug = flip trace

permutationEqual a b = all (==True) (zipWith (\a b -> a == b) a b)

solve :: (Int, Maybe [Int], Int, Int) -> (Int, [Int], [Int]) -> (Int, Maybe [Int], Int, Int)
solve (idx, Nothing, pi, qi) (size, ps, qs) = (idx, Nothing, pi, qi)
solve (idx, _, pi, qi) _ | pi /= 0 && qi /= 0 = (idx, Nothing, pi, qi)
solve (idx, Just permutation, pi, qi) (size, ps, qs)
  | permutationEqual permutation ps = (idx + 1, npermutation, idx, qi) -- `debug` (mconcat [show permutation, show npermutation])
  | permutationEqual permutation qs = (idx + 1, npermutation, pi, idx) -- `debug` (mconcat [show permutation, show npermutation])
  | otherwise = (idx + 1, npermutation, pi, qi) -- `debug` (mconcat [show permutation, show npermutation])
  where
    npermutation = nextPermutation permutation

main =
  read <$> getLine >>= \size ->
  fmap (map read . words) getLine >>= \ps ->
  fmap (map read . words) getLine >>= \qs ->
  let
    factorial n = product [1..n]
    (_, _, pi, qi) = foldl solve (1, Just [1..size], 0, 0) [(size, ps, qs) | d <- [1..factorial size]]
    result = abs (pi - qi)
   in
   if permutationEqual ps qs
      then putStrLn "0"
      else putStrLn $ show result