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

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
using static System.Console;
using static System.Math;
class Z { static void Main() => new K(); }
class K
{
	int F => int.Parse(Str);
	long FL => long.Parse(Str);
	int[] G => Strs.Select(int.Parse).ToArray();
	long[] GL => Strs.Select(long.Parse).ToArray();
	string Str => ReadLine();
	string[] Strs => Str.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
	const int MOD = 1000000007;
	public K()
	{
		SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
		Solve();
		Out.Flush();
	}
	void Solve()
	{
		var N = F;
		var x = new int[2 * N];
		var c = new int[2 * N];
		var rev = new int[2, N];
		for (var i = 0; i < 2 * N; i++)
		{
			var s = Strs;
			c[i] = s[0] == "W" ? 0 : 1;
			x[i] = int.Parse(s[1]) - 1;
			rev[c[i], x[i]] = i;
		}
		var cost = new int[2, 2 * N, N + 1];
		for (var i = 0; i < 2; i++)
			for (var v = 0; v <= N; v++)
			{
				for (var k = 0; k < 2 * N; k++) if (c[k] == i && x[k] < v) cost[i, k, v] = 1;
				for (var k = 2 * N - 2; k >= 0; k--) cost[i, k, v] += cost[i, k + 1, v];
			}
		var dp = new int[N + 1, N + 1];
		for (var i = 0; i < N; i++) dp[i + 1, 0] = dp[i, 0] + cost[0, rev[0, i], i];
		for (var j = 0; j < N; j++) dp[0, j + 1] = dp[0, j] + cost[1, rev[1, j], j];
		for (var i = 0; i < N; i++)
			for (var j = 0; j < N; j++)
			{
				dp[i + 1, j + 1] = Min(dp[i + 1, j] + cost[1, rev[1, j], j] + cost[0, rev[1, j], i + 1],
				dp[i, j + 1] + cost[0, rev[0, i], i] + cost[1, rev[0, i], j + 1]);
			}
		WriteLine(dp[N, N]);
	}
}