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 Java (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        cache.clear();
        //System.out.println(dp("WWRR", 0, "WWRR".length()-1));
        System.out.println(dp(s, 0, s.length()-1));
        /*long N = scanner.nextInt(),ans=0,i;
        //N*X -> 7*10^3+7*10^2+7*10^1+7 => 7(10^3+10^2+10^1+1) => 7(1 + 10*(10^2+10+1)) => 7(1+10+ 100*(10^2+10+1))
                                                                //7(1+10(1+10*(1+10*(1+10*())))

        if (N%7==0)
            N/=7;
        if (N%2==0) {
            System.out.println("-1");
            return;
        }

        //factor of 7?
        long cum = 0;
        for (int j = 1; j < N+10; j++) {
            cum = cum*10L+1;
            if (cum>N)
                cum=cum%N;
            if (cum==N || cum==0) {
                System.out.println(j);
                return;
            }
        }
        System.out.println("-1");
        /*
        7(1)
         7 + 10 * 7
            7 + 10 * 7 + 700
                1 + 10 + 100
         **/
        //10^x-1/9 = N*X/7, 10^x = N*X*9/7+1  =>
        //N*X => 0, 7, 7*11 , 7 * 111
        //BigInteger num = new BigInteger("7"), N1 = new BigInteger(N+""), N2 = BigInteger.ONE;
        /*for (i = 1; i <= N&&N%2==1; i++) {
            if (num.mod(N1).equals(BigInteger.ZERO))
                break;
            N2=N2.multiply(BigInteger.TEN).add(BigInteger.ONE);
            num=num.multiply(N2);
        }
        System.out.println((i==N+1||N%2==0)?"-1":i);*/
    }

    static Map<String, Integer> cache = new HashMap<>();
    private static int dp(String s, int i, int i1) {
        //System.out.println(s + "\t" + i + "\t" + i1);
        if (i>=i1)return 0;
        if (s.charAt(i)=='R')
            return dp(s, i+1,i1);
        if (s.charAt(i1)=='W')
            return dp(s, i,i1-1);
        String key = i + " " + i1;
        if (cache.containsKey(key))
            return cache.get(key);
        int ans = Math.min(
                1+dp(s, i+1,i1-1),
                1+dp(s, i,i1-1)
        );
        cache.put(key, ans);
        return ans;
    }

}