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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args) {
#if DEBUG
        MyDebugger.Test(process, "../TextFile1.txt");
        //MyDebugger.Test(process, "../TextFile2.txt");
        //MyDebugger.MakeTestCase("../TextFile2.txt");
#else
        object ret = process(new StreamReader(Console.OpenStandardInput()));
        Console.WriteLine(ret);
#endif
    }

    static object process(TextReader input) {
        var n = int.Parse(input.ReadLine());
        var pp = input.ReadLine().Trim();//ToIntArray(input.ReadLine(), n);
        var qq = input.ReadLine().Trim();//ToIntArray(input.ReadLine(), n);

        var ary = new int[n];
        for (int i = 0; i < n; i++) ary[i] = i+1;

        var list = AllPattern(ary);
        var slist = new List<string>();
        foreach(var x in list) {
            var b = new StringBuilder(n * 2);
            foreach(var y in x) {
                b.Append(y);
                b.Append(' ');
            }
            slist.Add(b.ToString().Trim());
        }

        slist.Sort();
        var pn = 0;
        var qn = 0;
        for(int i=0; i<slist.Count; i++) {
            if (slist[i] == pp) pn = i;
            if (slist[i] == qq) qn = i; 
        }

        return Math.Abs(pn-qn);
    }

    static int[] ToIntArray(string strs, int n) {
        var ret = new int[n];
        var spl =strs.Split(' ');
        for (int i = 0; i < n; i++)
            ret[i] = int.Parse(spl[i]);
        return ret;
    }

    static List<T[]> AllPattern<T>(T[] input) {
        return AllPattern(input, new HashSet<int>());
    }
    static List<T[]> AllPattern<T>(T[] input, HashSet<int>usedidx) {
        var ret = new List<T[]>();

        for(int i=0; i<input.Length; i++) {
            if (usedidx.Contains(i)) continue;

            if (usedidx.Count == input.Length-1) {
                var ary = new T[input.Length];
                ary[usedidx.Count] = input[i];
                ret.Add(ary);
            } else {
                var usedidx2 = new HashSet<int>(usedidx);
                usedidx2.Add(i);
                var sublist = AllPattern(input, usedidx2);
                //usedidx.Add(i);
                //var sublist = AllPattern(input, usedidx);
                //usedidx.Remove(i);

                foreach (var sub in sublist) {
                    var ary = new T[input.Length];
                    Array.Copy(sub, ary, ary.Length);
                    ary[usedidx.Count] = input[i];
                    ret.Add(ary);
                }
            }
        }

        return ret;
    }
}