Related Articles
Maximum length subsequence possible of the form R^N K^N
• Difficulty Level : Basic
• Last Updated : 26 Apr, 2019

Given a string containing only two characters i.e. R and K (like RRKRRKKKKK). The task is to find the maximum value of N for a subsequence possible of the form R—N times and then K—N times (i.e. of the form R^N K^N).

Note: String of k should be started after the string of R i.e. first k that would be considered for ‘K’ string must occur after the last R of the ‘R’ string in the given string. Also, the length of the resulting subsequence will be 2*N.

Examples:

Input: RRRKRRKKRRKKK
Output: 5
If we take R’s at indexes 0, 1, 2, 4, 5 and K’s at indexes 6, 7, 10, 11, 12
then we get a maximum subsequence of the form R^N K^N, where N = 5.

Input: KKKKRRRRK
Output: 1
If we take R at index 4( or 5 or 6 or 7) and K at index 8
then we get the desired subsequence with N = 1.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Calculate the number of R’s before a K .
2. Calculate the number of K’s after a K, including that K.
3. Store them in a table with a number of R’s in table[x] and a number of K’s in table[x].
4. Minimum of the two gives the value of n for each K and we will the return the maximum n.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the maximum``// length of a substring of form R^nK^n``#include``using` `namespace` `std;`` ` `    ``// function to calculate the maximum``    ``// length of substring of the form R^nK^n``    ``int` `find(string s)``    ``{``        ``int` `max = 0, i, j = 0, countk = 0, countr = 0;``        ``int` `table[s.length()];`` ` `        ``// Count no. Of R's before a K``        ``for` `(i = 0; i < s.length(); i++) {``            ``if` `(s[i] == ``'R'``)``                ``countr++;``            ``else``                ``table[j++] = countr;``        ``}``        ``j--;`` ` `        ``// Count no. Of K's after a K``        ``for` `(i = s.length() - 1; i >= 0; i--) {``            ``if` `(s[i] == ``'K'``) {``                ``countk++;``                ``table[j--] = countk;``            ``}`` ` `            ``// Update maximum length ``            ``if` `(min(table[j + 1], table[j + 1]) > max)``                ``max = min(table[j + 1], table[j + 1]);``        ``}`` ` `        ``return` `max;``    ``}`` ` `    ``// Driver code``    ``int` `main()``    ``{``        ``string s = ``"RKRRRKKRRKKKKRR"``;``        ``int` `n = find(s);``        ``cout<<(n);``    ``}``// This code is contributed by``// Surendra_Gangwar`

## Java

 `// Java program to find the maximum ``// length of a substring of form R^nK^n ``public` `class` `gfg { `` ` `    ``// function to calculate the maximum ``    ``// length of substring of the form R^nK^n ``    ``int` `find(String s) ``    ``{ ``        ``int` `max = ``0``, i, j = ``0``, countk = ``0``, countr = ``0``; ``        ``int` `table[][] = ``new` `int``[s.length()][``2``]; `` ` `        ``// Count no. Of R's before a K ``        ``for` `(i = ``0``; i < s.length(); i++) { ``            ``if` `(s.charAt(i) == ``'R'``) ``                ``countr++; ``            ``else``                ``table[j++][``0``] = countr; ``        ``} ``        ``j--; `` ` `        ``// Count no. Of K's after a K ``        ``for` `(i = s.length() - ``1``; i >= ``0``; i--) { ``            ``if` `(s.charAt(i) == ``'K'``) { ``                ``countk++; ``                ``table[j--][``1``] = countk; ``            ``} `` ` `            ``// Update maximum length ``            ``if` `(Math.min(table[j + ``1``][``0``], table[j + ``1``][``1``]) > max) ``                ``max = Math.min(table[j + ``1``][``0``], table[j + ``1``][``1``]); ``        ``} `` ` `        ``return` `max; ``    ``} `` ` `    ``// Driver code ``    ``public` `static` `void` `main(String srgs[]) ``    ``{ ``        ``String s = ``"RKRRRKKRRKKKKRR"``; ``        ``gfg ob = ``new` `gfg(); ``        ``int` `n = ob.find(s); ``        ``System.out.println(n); ``    ``} ``} `

## Python3

 `# Python3 program to find the maximum ``# length of a substring of form R^nK^n `` ` `# Function to calculate the maximum ``# length of substring of the form R^nK^n ``def` `find(s): ``      ` `    ``Max` `=` `j ``=` `countk ``=` `countr ``=` `0` `    ``table ``=` `[[``0``, ``0``] ``for` `i ``in` `range``(``len``(s))] `` ` `    ``# Count no. Of R's before a K ``    ``for` `i ``in` `range``(``0``, ``len``(s)):  ``        ``if` `s[i] ``=``=` `'R'``: ``            ``countr ``+``=` `1``        ``else``:``            ``table[j][``0``] ``=` `countr``            ``j ``+``=` `1``          ` `    ``j ``-``=` `1`` ` `    ``# Count no. Of K's after a K ``    ``for` `i ``in` `range``(``len``(s) ``-` `1``, ``-``1``, ``-``1``):  ``        ``if` `s[i] ``=``=` `'K'``:  ``            ``countk ``+``=` `1` `            ``table[j][``1``] ``=` `countk``            ``j ``-``=` `1``          ` `        ``# Update maximum length ``        ``if` `min``(table[j ``+` `1``][``0``], table[j ``+` `1``][``1``]) > ``Max``: ``            ``Max` `=` `min``(table[j ``+` `1``][``0``], table[j ``+` `1``][``1``]) ``          ` `    ``return` `Max` `      ` `# Driver code ``if` `__name__ ``=``=` `"__main__"``: ``      ` `    ``s ``=` `"RKRRRKKRRKKKKRR"` `    ``print``(find(s)) ``     ` `# This code is contributed by Rituraj Jain`

## C#

 `// C# program to find the maximum``// length of a substring of ``// form R^nK^n``using` `System;`` ` `class` `GFG ``{`` ` `// function to calculate the ``// maximum length of substring``// of the form R^nK^n``static` `int` `find(String s)``{``    ``int` `max = 0, i, j = 0, ``        ``countk = 0, countr = 0;``    ``int` `[,]table= ``new` `int``[s.Length, 2];`` ` `    ``// Count no. Of R's before a K``    ``for` `(i = 0; i < s.Length; i++) ``    ``{``        ``if` `(s[i] == ``'R'``)``            ``countr++;``        ``else``            ``table[(j++),0] = countr;``    ``}``    ``j--;`` ` `    ``// Count no. Of K's after a K``    ``for` `(i = s.Length - 1; i >= 0; i--) ``    ``{``        ``if` `(s[i] == ``'K'``)``        ``{``            ``countk++;``            ``table[j--, 1] = countk;``        ``}`` ` `        ``// Update maximum length ``        ``if` `(Math.Min(table[j + 1, 0], ``                     ``table[j + 1, 1]) > max)``            ``max = Math.Min(table[j + 1, 0], ``                           ``table[j + 1, 1]);``    ``}`` ` `    ``return` `max;``}`` ` `// Driver code``static` `public` `void` `Main(String []srgs)``{``    ``String s = ``"RKRRRKKRRKKKKRR"``;``    ``int` `n = find(s);``    ``Console.WriteLine(n);``}``}`` ` `// This code is contributed``// by Arnab Kundu`
Output:
```4
```

Time Complexity: O(n) where ln is the length of the substring.

My Personal Notes arrow_drop_up