Bear Limak prepares problems for a programming competition. Of course, it would be unprofessional to mention the sponsor name in the statement. Limak takes it seriously and he is going to change some words. To make it still possible to read, he will try to modify each word as little as possible.Limak has a string s that consists of uppercase English letters. In one move he can swap two adjacent letters of the string. For example, he can transform a string "ABBC" into "BABC" or "ABCB" in one move.Limak wants to obtain a string without a substring "VK" (i.e. there should be no letter 'V' immediately followed by letter 'K'). It can be easily proved that it's possible for any initial string s.What is the minimum possible number of moves Limak can do?

The first line of the input contains an integer n (1 ≤ n ≤ 75) — the length of the string. The second line contains a string s, consisting of uppercase English letters. The length of the string is equal to n.

Print one integer, denoting the minimum possible number of moves Limak can do, in order to obtain a string without a substring "VK".

NoteIn the first sample, the initial string is "VKVK". The minimum possible number of moves is 3. One optimal sequence of moves is: Swap two last letters. The string becomes "VKKV". Swap first two letters. The string becomes "KVKV". Swap the second and the third letter. The string becomes "KKVV". Indeed, this string doesn't have a substring "VK".In the second sample, there are two optimal sequences of moves. One is "BVVKV"  →  "VBVKV"  →  "VVBKV". The other is "BVVKV"  →  "BVKVV"  →  "BKVVV".In the fifth sample, no swaps are necessary.

using System;
using System.Linq;
using System.Collections.Generic;
using Debug = System.Diagnostics.Debug;
using StringBuilder = System.Text.StringBuilder;
using Number = System.Boolean;
namespace Program
{
    public class Solver
    {

        public void Solve()
        {
            var n = sc.Integer();
            var s = sc.Scan();
            var X = new List<int>();
            var Y = new List<int>();
            var Z = new List<int>();
            for (int i = 0; i < n; i++)
            {
                var c = s[i];
                if (c == 'V') { X.Add(i); }
                else if (c == 'K') { Y.Add(i); }
                else { Z.Add(i); }
            }
            var x = X.Count; var y = Y.Count; var z = Z.Count;
            X.Add(n + 1000000); Y.Add(n + 1000000); Z.Add(n + 1000000);
            var D = new List<int>[] { X, Y, Z };
            var dp = new int[x + 2, y + 2, 2];
            for (int i = 0; i < x + 2; i++)
                for (int j = 0; j < y + 2; j++)
                    for (int k = 0; k < 2; k++)
                        dp[i, j, k] = 1000000;
            dp[0, 0, 0] = 0;
            for (int pos = 0; pos < n; pos++)
            {
                var next = new int[x + 2, y + 2, 2];
                for (int i = 0; i < x + 2; i++)
                    for (int j = 0; j < y + 2; j++)
                        for (int k = 0; k < 2; k++)
                            next[i, j, k] = 1000000;
                for (int a = 0; a < x + 1; a++)
                    for (int b = 0; b < y + 1; b++)
                    {
                        var c = pos - a - b;
                        if (c < 0) continue;
                        if (c > z) continue;
                        var vec = new int[] { a, b, c };
                        for (int k = 0; k < 2; k++)
                        {
                            if (dp[a, b, k] >= 1000000) continue;
                            next[a + 1, b, 1] = Math.Min(next[a + 1, b, 1], dp[a, b, k] + d(X[a], 0, vec, D));
                            if (k != 1)
                                next[a, b + 1, 0] = Math.Min(next[a, b + 1, 0], dp[a, b, k] + d(Y[b], 1, vec, D));
                            next[a, b, 0] = Math.Min(next[a, b, 0], dp[a, b, k] + d(Z[c], 2, vec, D));
                        }
                    }
                dp = next;
            }
            IO.Printer.Out.WriteLine(Math.Min(dp[x, y, 0], dp[x, y, 1]));

        }
        int d(int p, int k, int[] P, List<int>[] D)
        {
            var v = 0;
            for (int i = 0; i < 3; i++)
            {
                if (i == k) continue;
                for (int j = 0; j < P[i]; j++)
                    if (p < D[i][j]) v++;
            }
            return v;
        }

        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());
        static T[] Enumerate<T>(int n, Func<int, T> f) { var a = new T[n]; for (int i = 0; i < n; ++i) a[i] = f(i); return a; }
        static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
    }
}

#region main
static class Ex
{
    static public string AsString(this IEnumerable<char> ie) { return new string(System.Linq.Enumerable.ToArray(ie)); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") { return string.Join(st, ie); }
    static public void Main()
    {
        var solver = new Program.Solver();
        solver.Solve();
        Program.IO.Printer.Out.Flush();
    }
}
#endregion
#region Ex
namespace Program.IO
{
    using System.IO;
    using System.Text;
    using System.Globalization;
    public class Printer: StreamWriter
    {
        static Printer() { Out = new Printer(Console.OpenStandardOutput()) { AutoFlush = false }; }
        public static Printer Out { get; set; }
        public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        public Printer(System.IO.Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
        public Printer(System.IO.Stream stream, Encoding encoding) : base(stream, encoding) { }
        public void Write<T>(string format, T[] source) { base.Write(format, source.OfType<object>().ToArray()); }
        public void WriteLine<T>(string format, T[] source) { base.WriteLine(format, source.OfType<object>().ToArray()); }
    }
    public class StreamScanner
    {
        public StreamScanner(Stream stream) { str = stream; }
        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }
        private byte read()
        {
            if (isEof) return 0;
            if (ptr >= len) { ptr = 0; if ((len = str.Read(buf, 0, 1024)) <= 0) { isEof = true; return 0; } }
            return buf[ptr++];
        }
        public char Char() { byte b = 0; do b = read(); while ((b < 33 || 126 < b) && !isEof); return (char)b; }

        public string Scan()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n'; b = (char)read())
                if (b == 0) break;
                else if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long()
        {
            if (isEof) return long.MinValue;
            long ret = 0; byte b = 0; var ng = false;
            do b = read();
            while (b != 0 && b != '-' && (b < '0' || '9' < b));
            if (b == 0) return long.MinValue;
            if (b == '-') { ng = true; b = read(); }
            for (; true; b = read())
            {
                if (b < '0' || '9' < b)
                    return ng ? -ret : ret;
                else ret = ret * 10 + b - '0';
            }
        }
        public int Integer() { return (isEof) ? int.MinValue : (int)Long(); }
        public double Double() { var s = Scan(); return s != "" ? double.Parse(s, CultureInfo.InvariantCulture) : double.NaN; }
        private T[] enumerate<T>(int n, Func<T> f)
        {
            var a = new T[n];
            for (int i = 0; i < n; ++i) a[i] = f();
            return a;
        }

        public char[] Char(int n) { return enumerate(n, Char); }
        public string[] Scan(int n) { return enumerate(n, Scan); }
        public double[] Double(int n) { return enumerate(n, Double); }
        public int[] Integer(int n) { return enumerate(n, Integer); }
        public long[] Long(int n) { return enumerate(n, Long); }
    }
}
#endregion