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 Ruby (2.3.3) (judge verdict: Time Limit Exceeded)

class SegTree
  attr_reader :original_size, :internal_size, :op

  def initialize(original_size, unit, &op)
    @original_size = original_size
    @op = op
    h = 0
    while (1 << h) < original_size
      h += 1
    end
    @internal_size = (1 << h)
    @height = h
    @array = Array.new((1 << (h+1)) - 1, unit)
  end

  def update(i, val)
    os = 0
    bs = @internal_size
    @array[i] = val
    @height.times do
      j = (os + i) | 1
      val = @op.call(@array[j ^ 1], @array[j])
      i >>= 1
      os |= bs
      bs >>= 1
      @array[os+i] = val
    end
    @array[-1]
  end

  def find(a,b)
    lv = nil; rv = nil
    os = 0
    bs = @internal_size
    while a < b
      if (a&1) == 1
        lv = lv ? @op.call(lv, @array[a]) : @array[a]
        a += 1
      end

      if (b&1) == 0
        rv = rv ? @op.call(@array[b], rv) : @array[b]
        b += -1
      end

      a = ((a-os) >> 1) | os | bs
      b = ((b-os) >> 1) | os | bs
      os |= bs
      bs >>= 1
    end

    if a == b
      lv = lv ? @op.call(lv, @array[a]) : @array[a]
    end
    rv ? @op.call(lv, rv) : lv
  end

  def data
    @array[0...@original_size]
  end

  def fulldata
    @array
  end
end

N = gets.to_i
bs = Array.new(N+1, nil)
ws = Array.new(N+1, nil)
(0...2*N).each{ |i|
  c,a = gets.split
  (c == "B" ? bs : ws)[a.to_i] = i
}

INF = N**3
balls = (0..N).map{ SegTree.new(2*N, 0) {|a,b| a+b } }
(0..N).each{ |x|
  (1..N).each{   |k| balls[x].update(ws[k], 1) }
  (x+1..N).each{ |k| balls[x].update(bs[k], 1) }
}

#balls.each{ |t| p (0...2*N).map{ |k| t.find(0,k) } }
dp = Array.new(N+1, INF)
dp[0] = 0
(0...N).each{ |x|
  dp[x+1] = dp[x] + balls[x].find(0,bs[x+1]) - 1
}

(0...N).each{ |y|
  dp[0] = dp[0] + balls[0].find(0,ws[y+1]) - 1
  balls[0].update(ws[y+1], 0)
  (0...N).each{ |x|
    v = dp[x  ] + balls[x  ].find(0,bs[x+1]) - 1
    w = dp[x+1] + balls[x+1].find(0,ws[y+1]) - 1
    dp[x+1] = v < w ? v : w
    balls[x+1].update(ws[y+1], 0)
  }
}
p dp[-1]