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

# matrixの基本操作

def same_el(array_)
  if array_.kind_of?(Array)
    output = []
    for i in  0..(array_.count-1)
      output.push(array_[i])
    end
  end
  return output
end

# ---------------------------------------------

def replace(n)

  sgn=[]
  remain=[]
  output=[] #n!個の要素を持つ配列を返す
  for i in 0..n
    sgn << i
    remain << i
  end
  output << []
  for i in 0..n
    output[0] << i
  end

  while true
    remain_act = same_el(remain)
    remain_act.delete(0)
    for i in 1..n-1
      judge_order = true
      for j in i+1..n-1
        sgn[j]<sgn[j+1] && judge_order = false
      end
      judge_order && break
      remain_act.delete(sgn[i])
    end
    singular = i
    remain_act.sort!
    for i in 0..n-(singular-2)
      if sgn[singular] == remain_act[i]
        sgn[singular] = remain_act[i+1]
        break
      end
    end
    remain_act.delete(sgn[singular])
    for i in singular+1..n
      sgn[i] = remain_act[i-(singular+1)]
    end
    inp =same_el(sgn)
    output << inp
    lastmat=true
    for i in 1..n
      sgn[i] != n+1-i && lastmat=false
    end
    lastmat && break
  end

  for i in 0..output.count-1
    output[i].delete(0)
  end
  output
end

# ---------------------------------------------

def signal(replaces)
  output = Array.new
  index = Array.new

  replace.size.times do |i|
    for j in 0..replaces.size-1
      index[j] = j+1
    end
    i_op = i.clone
    while true
      j = 0
      nimotu = index[0]
      sgn_part = -1
      while true
        if i_op[j] == nimotu

        else
        end
      end

    end
    output << sgn
  end
end

# ---------------------------------------------


class Matrix
  attr_accessor :matrix

  def initialize(matrix)
    @matrix = matrix
  end

  def self.times(matA,matB)
    if !matA.kind_of?(Matrix) || !matB.kind_of?(Matrix)
      return nil
    end

    if matA.size_mat[0] != matB.size_mat[1]
      return nil
    end

    sumcount = matA.size_mat[1]
    output =[]

    for i in 0 .. matA.size_mat[0]-1
      output.push([])
    end

    for i in 0 .. matA.size_mat[0]-1
      for j in 0 .. matB.size_mat[1]-1
        sum = 0
        for k in 0 .. sumcount-1
          sum += matA.matrix[i][k] * matB.matrix[k][j]
        end
        output[i].push(sum)
      end
    end
    return self.new(output)
  end

  def size_mat
    return [self.matrix.length,self.matrix[0].length]
  end

  def display
    digits_max = 1
    for i in 0..self.matrix.length-1
      for j in 0..self.matrix[i].length-1
        if self.matrix[i][j]!=0
          digits = Math.log10(self.matrix[i][j].abs).to_i+1
        else
          digits=1
        end
        if digits_max < digits
          digits_max = digits
        end
      end
    end

    for i in 0..self.matrix.length-1
      digits = 0
      for j in 0..self.matrix[i].length-1
        if j != self.matrix[i].length-1
          if self.matrix[i][j]!=0
            digits = Math.log10(self.matrix[i][j].abs).to_i+1
          else
            digits=1
          end
          print "#{self.matrix[i][j]} "+" "*(digits_max - digits)
        else
          print "#{self.matrix[i][j]}\n"
        end
      end
    end
  end
end

N=gets.to_i
ar=replace(N)
ps=gets.split.map(&:to_i)
qs=gets.split.map(&:to_i)
p (ar.index(ps)-ar.index(qs)).abs