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: Accepted)

-- 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)
import qualified Test.QuickCheck as QC

naive :: U.Vector Bool -> Int
naive v = let s0 = Seq.fromFunction (U.length v) (v U.!)
          in loop 0 [s0]
  where
    loop !i ss = case concat <$> mapM oneStep ss of
                   Nothing -> i
                   Just ss' -> loop (i+1) ss'

oneStep :: Seq.Seq Bool -> Maybe [Seq.Seq Bool]
oneStep s = let (s0,s1') = Seq.spanl not s
                (s2,s1) = Seq.spanr id s1'
            in if Seq.null s1 then
                 Nothing
               else
                 Just $ [ 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
                        ]

solve :: U.Vector Bool -> Int
solve xs = let ys0 = U.scanl' (\acc t -> if t then acc + 1 else acc) 0 xs
               ys1 = U.scanr' (\t acc -> if t then acc else acc + 1) 0 xs
               ys = U.zipWith max ys0 ys1
           in U.minimum ys

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 $ solve v

check :: [Bool] -> Bool
check xs = let v = U.fromList xs in solve v == naive v

runTest :: IO ()
runTest = QC.quickCheckWith (QC.stdArgs { QC.maxSize = 15 })  check