output_description: Print the minimum number of operations required to achieve the objective.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      c_1 a_1
      c_2 a_2
      :
      c_{2N} a_{2N}
attempt: def examC():
      ans = 0
      print(ans)
      return
  
  
  def examD():
      ans = 0
      print(ans)
      return
  
  
  # 解説AC
  def examE():
      N = I()
      Bnum = [-1] * N
      Wnum = [-1] * N
      B = {}
      W = {}
      for i in range(2 * N):
          c, a = LSI()
          a = int(a) - 1
          if c == "W":
              W[i] = a + 1
              Wnum[a] = i
          else:
              B[i] = a + 1
              Bnum[a] = i
      SB = [[0] * (N * 2) for _ in range(N + 1)]
      SW = [[0] * (N * 2) for _ in range(N + 1)]
      for i in range(2 * N):
          if not i in B:
              continue
          cur = B[i]
          cnt = 0
          SB[cur][i] = 0
          for j in range(2 * N):
              if not j in B:
                  SB[cur][j] = cnt
                  continue
              if B[j] <= cur:
                  cnt += 1
              SB[cur][j] = cnt
      for i in range(2 * N):
          if not i in W:
              continue
          cur = W[i]
          cnt = 0
          SW[cur][i] = 0
          for j in range(2 * N):
              if not j in W:
                  SW[cur][j] = cnt
                  continue
              if W[j] <= cur:
                  cnt += 1
              SW[cur][j] = cnt
      # for b in SB:
      # print(b)
      # print(SW)
      # print(SW,len(SW))
  
      dp = [[inf] * (N + 1) for _ in range(N + 1)]
      dp[0][0] = 0
      for i in range(N):
          dp[0][i + 1] = dp[0][i] + Bnum[i] - SB[i][Bnum[i]]
          dp[i + 1][0] = dp[i][0] + Wnum[i] - SW[i][Wnum[i]]
      # print(dp)
      for i in range(N):
          w = Wnum[i]
          for j in range(N):
              b = Bnum[j]
              costb = b - (SB[j][b] + SW[i + 1][b])
              costw = w - (SB[j + 1][w] + SW[i][w])
              # if i==2 and j==4:
              #    print(w,SB[i][w],SW[j+1][w])
              #    print(b,SB[i][b],SW[j+1][b])
              # print(costb,costw,i,j)
              # input()
              if costb < 0:
                  costb = 0
                  # print(i,j)
              if costw < 0:
                  costw = 0
                  # print(i,j)
              dp[i + 1][j + 1] = min(
                  dp[i + 1][j + 1], dp[i + 1][j] + costb, dp[i][j + 1] + costw
              )
      ans = dp[-1][-1]
      # for v in dp:
      #    print(v)
      print(ans)
      return
  
  
  def examF():
      ans = 0
      print(ans)
      return
  
  
  from decimal import getcontext, Decimal as dec
  import sys, bisect, itertools, heapq, math, random
  from copy import deepcopy
  from heapq import heappop, heappush, heapify
  from collections import Counter, defaultdict, deque
  
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  readlines = sys.stdin.buffer.readlines
  
  
  def I():
      return int(input())
  
  
  def LI():
      return list(map(int, sys.stdin.readline().split()))
  
  
  def DI():
      return dec(input())
  
  
  def LDI():
      return list(map(dec, sys.stdin.readline().split()))
  
  
  def LSI():
      return list(map(str, sys.stdin.readline().split()))
  
  
  def LS():
      return sys.stdin.readline().split()
  
  
  def SI():
      return sys.stdin.readline().strip()
  
  
  global mod, mod2, inf, alphabet, _ep
  mod = 10**9 + 7
  mod2 = 998244353
  inf = 10**18
  _ep = dec("0.000000000001")
  alphabet = [chr(ord("a") + i) for i in range(26)]
  alphabet_convert = {chr(ord("a") + i): i for i in range(26)}
  
  getcontext().prec = 28
  
  sys.setrecursionlimit(10**7)
  
  if __name__ == "__main__":
      examE()
  
  """
  142
  12 9 1445 0 1
  asd dfg hj o o
  aidn
  """
  
problem_description: 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.
samples: [{"input": "3\n    B 1\n    W 2\n    B 3\n    W 1\n    W 3\n    B 2", "output": "4\n    \n\nThe objective can be achieved in four operations, for example, as follows:\n\n  * Swap the black 3 and white 1.\n  * Swap the white 1 and white 2.\n  * Swap the black 3 and white 3.\n  * Swap the black 3 and black 2.\n\n* * *"}, {"input": "4\n    B 4\n    W 4\n    B 3\n    W 3\n    B 2\n    W 2\n    B 1\n    W 1", "output": "18\n    \n\n* * *"}, {"input": "9\n    W 3\n    B 1\n    B 4\n    W 1\n    B 5\n    W 9\n    W 2\n    B 6\n    W 5\n    B 3\n    W 8\n    B 9\n    W 7\n    B 2\n    B 8\n    W 4\n    W 6\n    B 7", "output": "41"}]