#include <algorithm>
#include <climits>
#include <functional>
#include <iterator>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

using namespace std;

#ifdef _MSC_VER
using ll = __int64;
using ull = unsigned __int64;
#else
using ll = long long int;
using ull = unsigned long long int;
#endif

// Range系のライブラリ
struct RangeIterator {
	ll v;
	const ll operator*() { return v; }
	RangeIterator& operator++() { ++v; return *this; }
	bool operator!=(const RangeIterator& rhs) { return v != rhs.v; }
};
template<bool INCLUSIVE> struct EndType {};
template<> struct EndType<false> {
	ll end;
	ll operator()() { return end; }
};
template<> struct EndType<true> {
	ll end;
	ll operator()() { return end + 1; }
};
template<bool INCLUSIVE>
struct Range {
	ll s; EndType<INCLUSIVE> e;
	Range(ll end) : s(0), e(EndType<INCLUSIVE>{end}) {}
	Range(ll start, ll end) : s(start), e(EndType<INCLUSIVE>{end}) {}
	RangeIterator begin() { return { s }; }
	RangeIterator end() { return { e() }; }
};
inline Range<false> range(ll start) { return Range<false>(start); }
inline Range<false> range(ll start, ll end) { return Range<false>(start, end); }
inline Range<true> irange(ll start) { return Range<true>(start); }
inline Range<true> irange(ll start, ll end) { return Range<true>(start, end); }

// 二乗を計算する。
ll sq(ll x) { return x * x; }

// 領域内にいるか。
bool within(ll x, ll min, ll max) {
	return min <= x && x <= max;
}

// container の中から key より小さい値を見つける。
// 見つからない場合は container.end() を返す。
template<typename T>
typename T::iterator less_than(T& container, typename T::key_type& key) {
	typename T::iterator prev = container.lower_bound(key);
	if (prev == container.begin()) prev = container.end();
	else prev--;
	return prev;
}

// container の中から key より大きい値を見つける。
// 見つからない場合は container.end() を返す。
template<typename T>
typename T::iterator greater_than(T & container, typename T::key_type & key) {
	return container.upper_bound(key);
}

// b^e (mod m) を求める
ll modpow(ll b, ll e, ll m) {
	ll result = 1;
	while (e > 0) {
		if ((e & 1) == 1) result = (result * b) % m;
		e >>= 1;
		b = (b * b) % m;
	}
	return result;
}


// ここから解法

const int MAX_N = 10000;
const int INF = 100;

int N;
vector<string> S;

// 0: AB以外終端
// 1: A終端
int dp[MAX_N + 100][2];

int main(void) {
	std::ios_base::sync_with_stdio(false);
	cin >> N; S.resize(N);
	for (auto i : range(N)) {
		cin >> S[i];
	}

	vector<int> a, b, o;
	vector<pair<int, int>> count;
	int result = 0;
	for (int i = 0; i < S.size(); ++i) {
		auto s = S[i];
		for (int i = 0; i < s.size() - 1; ++i) {
			if (s[i] == 'A' && s[i + 1] == 'B') result++;
		}
		if (s[s.size() - 1] == 'A' && s[0] == 'B') o.push_back(i);
		else if (s[s.size() - 1] == 'A') a.push_back(i);
		else if (s[0] == 'B') b.push_back(i);
	}

	int ac = a.size(), bc = b.size();
	result += max(0, (int)o.size() - 1);
	if (ac > 0 && o.size() > 0) {
		ac--; result++;
	}
	if (bc > 0 && o.size() > 0) {
		bc--; result++;
	}
	result += min(ac, bc);
	cout << result << endl;


	//dp[0][0] = 0;  dp[0][1] = -INF;
	//for (auto i : range(N)) {
	//	int v1 = 1 + min(count[i].first, count[i].second - 1);
	//	int v2 = min(count[i].first - 1, count[i].second - 1);
	//	dp[i + 1][0] += max(dp[i][0] + min(count[i].first, count[i].second),
	//		                dp[i][1] + max(v1, 0));
	//	dp[i + 1][1] += max(dp[i][0] + min(count[i].first - 1, count[i].second),
	//		                dp[i][1] + count[i].first > 0 ? max(v2, 0) : -INF);
	//}

	//cout << max(dp[N][0], dp[N][1]) << endl;

	return 0;
}


Measured memory_bytes: 896