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 (GCC 5.4.1) (judge verdict: Accepted)

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<limits.h>

#define rep(i,begin,end) for(int i=begin; i<end; i++)
#define lld long long int

void next_permutation(int* a, int n){
    int tmp, x=-1, y=-1, z;
    for(int i=n-1; i>0; i--){
        if(*(a+i-1) < *(a+i)){
            x = i-1;
            break;
        }
    }
    if(x==-1){
        return;
    }
    for(int i=n-1; i>=0; i--){
        if(*(a+x) < *(a+i)){
            y = i;
            break;
        }
    }
    tmp = *(a+x);
    *(a+x) = *(a+y);
    *(a+y) = tmp;
    for(int i=x+1; i<n; i++){
        z = n-(i-x);
        if(i < z){
            tmp = *(a+z);
            *(a+z) = *(a+i);
            *(a+i) = tmp;
        }else{
            break;
        }
    }
    return;
}

int main(){
    int n;
    scanf("%d", &n);
    int p[n], q[n], r[n];
    rep(i, 0, n){
        scanf("%d", &p[i]);
        r[i] = i+1;
    }
    rep(i, 0, n){
        scanf("%d", &q[i]);
    }
    int x=1, a=-1, b=-1;
    while(a==-1 || b==-1){
        /*rep(i, 0, n){
            printf("%d ", r[i]);
        }
        printf("\n");*/
        if(memcmp(p, r, sizeof(p))==0){
            a = x;
        }
        if(memcmp(q, r, sizeof(q))==0){
            b = x;
        }
        next_permutation(r, n);
        x++;
    }
    printf("%d", abs(a-b));

    return 0;
}