# Comparar rankings

Un festival de cortometrajes pidió a dos jurados que ordenaran las mismas n películas, de la que más les gustó a la que menos.
Cada película tiene un código entre 1 y n. Los organizadores quieren saber cuánto se parecen las dos listas, y para eso cuentan los **pares en desacuerdo**: un par de
películas está en desacuerdo si el primer jurado pone a una antes que la otra, y el segundo jurado las pone al revés.

Dos listas iguales no tienen ningún par en desacuerdo. Una lista y esa misma lista al revés están en desacuerdo en todos los pares.

Escriban un programa que calcule cuántos pares están en desacuerdo.

## Entrada

La primera línea tiene el entero n, la cantidad de películas.

La segunda línea tiene n enteros: los códigos de las películas en el orden del primer jurado, del primer lugar al último.

La tercera línea tiene n enteros: los códigos en el orden del segundo jurado.

Cada una de las dos listas contiene cada código de 1 a n exactamente una vez.

## Salida

Una línea con la cantidad de pares de películas en desacuerdo.

## Límites

- 1 ≤ n ≤ 300 000.

## Ejemplo

Entrada:

```text
5
3 1 4 5 2
1 3 2 5 4
```

Salida:

```text
4
```

Los pares en desacuerdo son (3, 1), (4, 5), (4, 2) y (5, 2). Por ejemplo, el primer jurado pone a la película 3 antes que la 1, y el segundo, a la 1 antes que la 3.

## Tiempo

2 segundos por caso.

## Cómo trabajar

1. Reduzcan el problema: ¿cómo se escribe la pregunta sobre dos listas como una pregunta sobre un solo arreglo?
2. Escriban primero la versión que revisa todos los pares. Debe dar AC en los casos pequeños y TLE en los grandes. Guárdenla: les servirá para comparar respuestas en casos chicos al azar.
3. Escriban la versión rápida, y hagan que pase todos los casos.
4. Midan su versión final con n y con 2n. El generador del caso 08 acepta otro n:

   ```sh
   g++ -O2 -std=c++20 casos/gen_08.cpp -o build/gen_08
   build/gen_08 150000 > build/n.in
   build/gen_08 300000 > build/2n.in
   time build/solution < build/n.in
   time build/solution < build/2n.in
   ```

   Repitan varias veces y con varios tamaños, y comparen la razón entre los tiempos con la que predice la recurrencia de su algoritmo. ¿Qué pasa con esa razón en la versión que revisa todos los pares?