Problem:
Score : 600 points

Problem Statement

There are 2N balls, N white and N black, arranged in a row. The integers from 1 through N are written on the white balls, one on each ball, and they are also written on the black balls, one on each ball.
The integer written on the i-th ball from the left (1 ≤ i ≤ 2N) is a_i, and the color of this ball is represented by a letter c_i.
c_i = W represents the ball is white; c_i = B represents the ball is black.

Takahashi the human wants to achieve the following objective:

For every pair of integers (i,j) such that 1 ≤ i < j ≤ N, the white ball with i written on it is to the left of the white ball with j written on it.

For every pair of integers (i,j) such that 1 ≤ i < j ≤ N, the black ball with i written on it is to the left of the black ball with j written on it.

In order to achieve this, he can perform the following operation:

Swap two adjacent balls.

Find the minimum number of operations required to achieve the objective.

Constraints

1 ≤ N ≤ 2000

1 ≤ a_i ≤ N

c_i = W or c_i = B.

If i ≠ j, (a_i,c_i) ≠ (a_j,c_j).

Input

Input is given from Standard Input in the following format:

N
c_1 a_1
c_2 a_2
:
c_{2N} a_{2N}

Output

Print the minimum number of operations required to achieve the objective.

Sample Input 1

3
B 1
W 2
B 3
W 1
W 3
B 2

Sample Output 1

4

The objective can be achieved in four operations, for example, as follows:

Swap the black 3 and white 1.

Swap the white 1 and white 2.

Swap the black 3 and white 3.

Swap the black 3 and black 2.

Sample Input 2

4
B 4
W 4
B 3
W 3
B 2
W 2
B 1
W 1

Sample Output 2

18

Sample Input 3

9
W 3
B 1
B 4
W 1
B 5
W 9
W 2
B 6
W 5
B 3
W 8
B 9
W 7
B 2
B 8
W 4
W 6
B 7

Sample Output 3

41

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>

using namespace std;

#define SZ(v) ((int)(v).size())
#define ALL(v) (v).begin(),(v).end()
#define one first
#define two second
typedef long long ll;
typedef pair<int, int> pi;
const int INF = 0x3f2f1f0f;
const ll LINF = 1ll * INF * INF;

const int MAX_N = 2e3 + 10;

struct BIT{
	vector<int> val;
	BIT(int n) {
		val = vector<int>(n+10, 0);
	}
	void update(int v, int k) {for(v+=5; v<SZ(val); v+=v&-v) val[v] += k;}
	int getSum(int v) {int res=0; for(v+=5; v>0; v-=v&-v) res += val[v]; return res;}
	int getSum(int a, int b) {return getSum(b) - getSum(a-1);}
};

int N, Ix[2][MAX_N];
ll Dy[MAX_N][MAX_N];
int main() {
	cin >> N;
	for(int i=1; i<=2*N; i++) {
		char s[5]; int v; scanf("%s%d", s, &v);
		Ix[s[0] == 'B'][v] = i;
	}
	BIT up = BIT(2*N);
	BIT lf = BIT(2*N);
	for(int i=0; i<=N; i++) {
		if(i) lf.update(Ix[0][i], 1);
		for(int j=0; j<=N; j++) {
			if(i+j == 0) continue;
			Dy[i][j] = LINF;
			if(i && j) up.update(Ix[1][j], 1);

			if(i) Dy[i][j] = min(Dy[i][j], Dy[i-1][j] + abs( (i+j) - (Ix[0][i] + up.getSum(Ix[0][i], 2*N) ) ) );
			if(j) Dy[i][j] = min(Dy[i][j], Dy[i][j-1] + abs( (i+j) - (Ix[1][j] + lf.getSum(Ix[1][j], 2*N) ) ) );

			if(j) lf.update(Ix[1][j], 1);
		}
		for(int j=1; j<=N; j++) {
			if(i) up.update(Ix[1][j], -1);
			if(j) lf.update(Ix[1][j], -1);
		}
		if(i) up.update(Ix[0][i], 1);
	}
	printf("%lld\n", Dy[N][N]);
	return 0;
}