 Open in App
Not now

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

• Difficulty Level : Basic
• Last Updated : 30 Nov, 2022

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

`32629`

Time Complexity: O(n) where n is the length of the given string.
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up