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 Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

struct Ball {
    color: bool,
    num: usize,
}

fn main() {
    let n: usize = read();

    let mut balls = Vec::new();
    for i in 0..2 * n {
        let v = read_vec::<String>();
        let new_ball = Ball {
            color: v[0] == "B",
            num: v[1].parse::<i32>().unwrap() as usize - 1,
        };
        balls.push(new_ball);
    }

    let mut cnt_w = vec![vec![0; n + 1]; 2 * n + 1];
    for i in 1..2 * n + 1 {
        for j in 0..n {
            if i > 0 {
                cnt_w[i][j] = cnt_w[i - 1][j];
            }
            if !balls[i - 1].color && balls[i - 1].num >= j {
                cnt_w[i][j] += 1;
            }
        }
    }
    // println!("cnt_w {:?}", cnt_w);

    let mut cnt_b = vec![vec![0; n + 1]; 2 * n + 1];
    for i in 1..2 * n + 1 {
        for j in 0..n {
            if i > 0 {
                cnt_b[i][j] = cnt_b[i - 1][j];
            }
            if balls[i - 1].color && balls[i - 1].num >= j {
                cnt_b[i][j] += 1;
            }
        }
    }
    // println!("cnt_b {:?}", cnt_b);

    let mut idx_w = vec![0; n];
    let mut idx_b = vec![0; n];
    for i in 0..2 * n {
        if balls[i].color {
            idx_b[balls[i].num] = i;
        } else {
            idx_w[balls[i].num] = i;
        }
    }
    // println!("{:?}", idx_w);
    // println!("{:?}", idx_b);

    let mut dp = vec![vec![std::usize::MAX; n + 1]; n + 1];
    dp[0][0] = 0;

    for i in 0..n + 1 {
        for j in 0..n + 1 {
            if i > 0 {
                let i_w_pos = idx_w[i - 1];
                dp[i][j] = min(
                    dp[i - 1][j] + cnt_w[i_w_pos][i - 1] + cnt_b[i_w_pos][j],
                    dp[i][j],
                );
            }
            if j > 0 {
                let j_b_pos = idx_b[j - 1];
                dp[i][j] = min(
                    dp[i][j - 1] + cnt_w[j_b_pos][i] + cnt_b[j_b_pos][j - 1],
                    dp[i][j],
                );
            }
        }
    }
    // println!("{:?}", dp);
    println!("{}", dp[n][n]);
}