# Maximum length subsequence possible of the form R^N K^N

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++ 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 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 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# 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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :