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: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using static Reader;
using static System.Math;
using MethodImplAttribute = System.Runtime.CompilerServices.MethodImplAttribute;
using MethodImplOptions = System.Runtime.CompilerServices.MethodImplOptions;

public static class P
{
    public static void Main()
    {
        int n = NextInt;
        var balls = Enumerable.Repeat(0, n * 2).Select(_ => new Ball() { Color = NextChar == 'B' ? Color.Black : Color.White, Number = NextInt }).ToList();
        int blackCount = n;
        int whiteCount = n;
        long res = 0;
        while (0 < blackCount && 0 < whiteCount)
        {
            var blackInd = balls.IndexOf(balls.Where(x => x.Color == Color.Black).Min());
            var whiteInd = balls.IndexOf(balls.Where(x => x.Color == Color.White).Min());
            int adoptedInd;
            if (blackInd < whiteInd)
            {
                adoptedInd = blackInd;
                blackCount--;
            }
            else
            {
                adoptedInd = whiteInd;
                whiteCount--;
            }
            res += adoptedInd;
            balls.RemoveAt(adoptedInd);
        }
        while (0 < balls.Count)
        {
            var min = balls.Min();
            var minInd = balls.IndexOf(min);
            res += minInd;
            balls.RemoveAt(minInd);
        }
        Console.WriteLine(res);
    }
}

struct Ball : IEqualityComparer<Ball>, IComparable<Ball>
{
    public Color Color;
    public int Number;

    public int CompareTo(Ball other) => Number.CompareTo(other.Number);

    public bool Equals(Ball x, Ball y) => x.Number == y.Number && x.Color == y.Color;

    public int GetHashCode(Ball obj) => obj.Number * (obj.Color == Color.Black ? 1 : -1);
    public override string ToString() => $"{Color} {Number}";
}

enum Color
{
    Black,
    White
}


static class Reader
{
    const int BUF_SIZE = 1 << 12;
    static Stream Stream = Console.OpenStandardInput();
    static byte[] Buffer = new byte[BUF_SIZE];
    static int ptr = BUF_SIZE - 1;
    static void Move() { if (++ptr >= Buffer.Length) { Stream.Read(Buffer, 0, BUF_SIZE); ptr = 0; } }

    public static char NextChar
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get
        {
            while (Buffer[ptr] <= 32) Move();
            var res = (char)Buffer[ptr];
            Move();
            return res;
        }
    }

    public static int NextInt
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get
        {
            int res = 0; while (Buffer[ptr] < 48) Move();
            do { res = res * 10 + (int)(Buffer[ptr] ^ 48); Move(); } while (48 <= Buffer[ptr]);
            return res;
        }
    }
}