Problem:
Score : 400 points

Problem Statement

Snuke has N strings. The i-th string is s_i.

Let us concatenate these strings into one string after arranging them in some order.
Find the maximum possible number of occurrences of AB in the resulting string.

Constraints

1 \leq N \leq 10^{4}

2 \leq |s_i| \leq 10

s_i consists of uppercase English letters.

Input

Input is given from Standard Input in the following format:

N
s_1
\vdots
s_N

Output

Print the answer.

Sample Input 1

3
ABCA
XBAZ
BAD

Sample Output 1

2

For example, if we concatenate ABCA, BAD and XBAZ in this order, the resulting string ABCABADXBAZ has two occurrences of AB.

Sample Input 2

9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA

Sample Output 2

4

Sample Input 3

7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA

Sample Output 3

4

Solution in Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

-- diverta 2019 C problem
import Control.Monad
import qualified Data.Text as T

-- conversion from String to Int
toInt :: String -> Int
toInt x = read x :: Int

-- obtain [Int] from I/O
getInts :: IO [Int]
getInts = do
  x <- getLine
  let y = (map $ toInt) $ words x
  return y

getLines :: IO T.Text
getLines = do
    x <- getLine
    let y = T.pack x
    return y

-- for each line
findAB :: T.Text -> Int
findAB s =
    if (T.tail s) == T.empty then 0
    else
        if (T.head s) == 'A' && (T.head (T.tail s)) == 'B' then 1 + (findAB (T.tail s))
        else (findAB (T.tail s))

totalInnerAB :: [T.Text] -> Int
totalInnerAB [] = 0
totalInnerAB (x:xs) = (findAB x) + (totalInnerAB xs)

countBhead :: [T.Text] -> Int
countBhead [] = 0
countBhead (x:xs) =
    if (T.head x == 'B') then 1 + (countBhead xs)
    else (countBhead xs)

countAbottom :: [T.Text] -> Int
countAbottom [] = 0
countAbottom (x:xs) =
    if (T.last x == 'A') then 1 + (countBhead xs)
    else (countAbottom xs)

proC :: [T.Text] -> Int
proC s = (totalInnerAB s) + (min (countAbottom s) (countBhead s))

-- main function
main :: IO ()
main = do
    n1 <- getInts
    let n = head n1
    ss <- replicateM n getLines
    print (proC ss)