Problem:
Score : 400 points

Problem Statement

An altar enshrines N stones arranged in a row from left to right. The color of the i-th stone from the left (1 \leq i \leq N) is given to you as a character c_i; R stands for red and W stands for white.

You can do the following two kinds of operations any number of times in any order:

Choose two stones (not necessarily adjacent) and swap them.

Choose one stone and change its color (from red to white and vice versa).

According to a fortune-teller, a white stone placed to the immediate left of a red stone will bring a disaster. At least how many operations are needed to reach a situation without such a white stone?

Constraints

2 \leq N \leq 200000

c_i is R or W.

Input

Input is given from Standard Input in the following format:

N
c_{1}c_{2}...c_{N}

Output

Print an integer representing the minimum number of operations needed.

Sample Input 1

4
WWRR

Sample Output 1

2

For example, the two operations below will achieve the objective.

Swap the 1-st and 3-rd stones from the left, resulting in RWWR.

Change the color of the 4-th stone from the left, resulting in RWWW.

Sample Input 2

2
RR

Sample Output 2

0

It can be the case that no operation is needed.

Sample Input 3

8
WRWWRWRR

Sample Output 3

3

Solution in Haskell (GHC 8.8.3) (judge verdict: Time Limit Exceeded)

-- https://github.com/minoki/my-atcoder-solutions
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE BangPatterns #-}
import qualified Data.Vector.Unboxed as U
import qualified Data.ByteString.Char8 as BS
import qualified Data.Sequence as Seq
import Data.Foldable (or)

naive :: U.Vector Bool -> Int
naive v = let s0 = Seq.fromFunction (U.length v) (v U.!)
          in loop 0 [s0]
  where
    loop !i ss = let ss' = map oneStep ss
                 in if any null ss' then
                      i
                    else
                      loop (i+1) $ concat ss'

oneStep :: Seq.Seq Bool -> [Seq.Seq Bool]
oneStep s = let (s0,s1') = Seq.spanl not s
                (s2,s1) = Seq.spanr id s1'
            in if Seq.null s1 then
                 []
               else
                 [ Seq.update j True $ Seq.update i False s1
                 | i <- Seq.elemIndicesL True s1
                 , j <- Seq.elemIndicesR False s1
                 ] ++
                 [ Seq.update i False s1
                 | i <- Seq.elemIndicesL True s1
                 ] ++
                 [ Seq.update j True s1
                 | j <- Seq.elemIndicesR False s1
                 ]

main = do
  n <- readLn @Int
  s <- BS.getLine -- 'R' or 'W'
  -- 操作後： replicate k 'R' ++ replicate (n - k) 'W' for some k
  let v = U.generate n (\i -> s `BS.index` i == 'W')
  print $ naive v