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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.InputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
	InputStream in = System.in;
	PrintStream out = System.out;

	private static <T extends Comparable<T>> boolean nextPermutation(List<T> l) {
		for (int i = l.size() - 2; i >= 0; i--) {
			// 辞書順に並んでいるところを探す
			if (l.get(i).compareTo(l.get(i + 1)) < 0) { // l[i] < l[i+1]
				int idx = i + 1;
				T min = l.get(i + 1);
				// l[i]より大きくて、そのうち最小を、i+1以降で探す
				for (int j = i + 1; j < l.size(); j++) {
					if (l.get(j).compareTo(l.get(i)) > 0) {
						if (l.get(j).compareTo(min) < 0) {
							idx = j;
							min = l.get(j);
						}
					}
				}

				Collections.swap(l, i, idx);
				Collections.sort(l.subList(i + 1, l.size()));
				return true;
			}
		}
		return false;
	}

	public void _main(String[] args) {
		Scanner sc = new Scanner(in);

		int N = sc.nextInt();
		List<Integer> P = new ArrayList<>();
		for (int i = 0; i < N; i++) {
			P.add(sc.nextInt());
		}
		List<Integer> Q = new ArrayList<>();
		for (int i = 0; i < N; i++) {
			Q.add(sc.nextInt());
		}

		sc.close();

		List<Integer> l = new ArrayList<>();
		for (int i = 1; i <= N; i++) {
			l.add(i);
		}

		int n = 1;
		int a = 0;
		int b = 0;
		do {

			if (l.equals(P)) {
				a = n;
			}
			if (l.equals(Q)) {
				b = n;
			}
			n++;

		} while (nextPermutation(l));

		out.println(Math.abs(a - b));

	}

	public static void main(String[] args) {
		new Main()._main(args);
	}
}