#include <bits/stdc++.h>
using namespace std;
const int MAX1 = 16, MAX2 = 1 << MAX1 + 1;
const short INF = 1 << 15 - 1;
struct card {
  bool type;
  int r, b;
};
struct mask {
  int bits, r, b;
};
int n, ans = 1e9, pls_r, pls_b;
card arr[MAX1];
vector<mask> masks_vec[MAX1 + 1];
mask masks_arr[MAX2];
short adp[MAX2][2][MAX1 * MAX1 + 1];
int main() {
  ios::sync_with_stdio(0);
  cin >> n;
  for (int i = 0; i < n; ++i) {
    char in;
    cin >> in >> arr[i].r >> arr[i].b;
    arr[i].type = (in == 'B');
    if (arr[i].r > n) pls_r += arr[i].r - n, arr[i].r = n;
    if (arr[i].b > n) pls_b += arr[i].b - n, arr[i].b = n;
  }
  for (int i = 0; i < (1 << n); ++i) {
    mask now;
    now.bits = i;
    now.r = now.b = 0;
    int j = 0, num = i;
    while (num) {
      if (num & 1) {
        if (!arr[j].type)
          ++now.r;
        else
          ++now.b;
      }
      num >>= 1;
      ++j;
    }
    masks_arr[i] = now;
    masks_vec[now.r + now.b].push_back(now);
  }
  for (int left = 1; left <= n * n; ++left)
    adp[0][0][left] = adp[0][1][left] = INF;
  for (int num = 1; num <= n; ++num) {
    for (mask m : masks_vec[num]) {
      int now = m.bits;
      for (int left = 0; left <= n * n; ++left)
        adp[now][0][left] = adp[now][1][left] = INF;
      for (int pos = 0; pos < n; ++pos) {
        if (now & (1 << pos)) {
          int prv = now ^ (1 << pos);
          for (int type = 0; type <= 1; ++type) {
            for (int left = 0; left <= n * n; ++left) {
              int prv_r = left * (!type), prv_b = left * type;
              short delta = max(0, max(arr[pos].r - prv_r - masks_arr[prv].r,
                                       arr[pos].b - prv_b - masks_arr[prv].b));
              int now_r = delta + prv_r - max(0, arr[pos].r - masks_arr[prv].r),
                  now_b = delta + prv_b - max(0, arr[pos].b - masks_arr[prv].b);
              if (now_r + now_b < INF &&
                  adp[prv][type][left] + delta + 1 <
                      adp[now][now_r == 0][now_r + now_b])
                adp[now][now_r == 0][now_r + now_b] =
                    adp[prv][type][left] + delta + 1;
            }
          }
        }
      }
    }
  }
  for (int type = 0; type <= 1; ++type)
    for (int left = 0; left <= n * n; ++left)
      if (adp[(1 << n) - 1][type][left] < INF) {
        int prv_r = left * (!type), prv_b = left * type;
        int delta = max(0, max(pls_r - prv_r, pls_b - prv_b));
        ans = min(int(adp[(1 << n) - 1][type][left]) + delta, ans);
      }
  cout << ans;
  return 0;
}
