Related Articles

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

• Difficulty Level : Basic
• Last Updated : 09 Jul, 2021

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.

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`

## Javascript

 ``
Output:
`4`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up