Count maximum occurrence of subsequence in string such that indices in subsequence is in A.P.
Given a string S, the task is to count the maximum occurrence of subsequences in the given string such that the indices of the characters of the subsequence are Arithmetic Progression.
Examples:
Input: S = “xxxyy”
Output: 6
Explanation:
There is a subsequence “xy”, where indices of each character of the subsequence are in A.P.
The indices of the different characters that form the subsequence “xy” –
{(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)}
Input: S = “pop”
Output: 2
Explanation:
There is a subsequence “p”, where indices of each character of the subsequence are in A.P.
The indices of the different characters that form the subsequence “p” –
{(1), (2)}
Approach: The key observation in the problem is if there are two characters in a string whose collective occurrence is greater than the occurrence of any single character, then these characters will form the maximum occurrence subsequence in the string with the character in, Arithmetic progression because every two integers will always form an arithmetic progression. Below is an illustration of the steps:
- Iterate over the string and count the frequency of the characters of the string. That is considering the subsequences of length 1.
- Iterate over the string and choose every two possible characters of the string and increment the frequency of the subsequence of the string.
- Finally, find the maximum frequency of the subsequence from lengths 1 and 2.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumOccurrence(string s)
{
int n = s.length();
map<string, int > freq;
for ( int i = 0; i < n; i++) {
string temp = "" ;
temp += s[i];
freq[temp]++;
}
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++) {
string temp = "" ;
temp += s[i];
temp += s[j];
freq[temp]++;
}
}
int answer = INT_MIN;
for ( auto it : freq)
answer = max(answer, it.second);
return answer;
}
int main()
{
string s = "xxxyy" ;
cout << maximumOccurrence(s);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maximumOccurrence(String s)
{
int n = s.length();
HashMap<String, Integer> freq = new HashMap<String,Integer>();
int i, j;
for ( i = 0 ; i < n; i++) {
String temp = "" ;
temp += s.charAt(i);
if (freq.containsKey(temp)){
freq.put(temp,freq.get(temp)+ 1 );
}
else {
freq.put(temp, 1 );
}
}
for (i = 0 ; i < n; i++) {
for (j = i + 1 ; j < n; j++) {
String temp = "" ;
temp += s.charAt(i);
temp += s.charAt(j);
if (freq.containsKey(temp))
freq.put(temp,freq.get(temp)+ 1 );
else
freq.put(temp, 1 );
}
}
int answer = Integer.MIN_VALUE;
for ( int it : freq.values())
answer = Math.max(answer, it);
return answer;
}
public static void main(String []args)
{
String s = "xxxyy" ;
System.out.print(maximumOccurrence(s));
}
}
|
Python3
def maximumOccurrence(s):
n = len (s)
freq = {}
for i in s:
temp = ""
temp + = i
freq[temp] = freq.get(temp, 0 ) + 1
for i in range (n):
for j in range (i + 1 , n):
temp = ""
temp + = s[i]
temp + = s[j]
freq[temp] = freq.get(temp, 0 ) + 1
answer = - 10 * * 9
for it in freq:
answer = max (answer, freq[it])
return answer
if __name__ = = '__main__' :
s = "xxxyy"
print (maximumOccurrence(s))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int maximumOccurrence( string s)
{
int n = s.Length;
Dictionary< string ,
int > freq = new Dictionary< string ,
int >();
int i, j;
for ( i = 0; i < n; i++)
{
string temp = "" ;
temp += s[i];
if (freq.ContainsKey(temp))
{
freq[temp]++;
}
else
{
freq[temp] = 1;
}
}
for (i = 0; i < n; i++)
{
for (j = i + 1; j < n; j++)
{
string temp = "" ;
temp += s[i];
temp += s[j];
if (freq.ContainsKey(temp))
freq[temp]++;
else
freq[temp] = 1;
}
}
int answer = int .MinValue;
foreach (KeyValuePair< string ,
int > it in freq)
answer = Math.Max(answer, it.Value);
return answer;
}
public static void Main( string []args)
{
string s = "xxxyy" ;
Console.Write(maximumOccurrence(s));
}
}
|
Javascript
<script>
function maximumOccurrence(s)
{
var n = s.length;
var freq = new Map();
for ( var i = 0; i < n; i++) {
var temp = "" ;
temp += s[i];
if (freq.has(temp))
freq.set(temp, freq.get(temp)+1)
else
freq.set(temp, 1)
}
for ( var i = 0; i < n; i++) {
for ( var j = i + 1; j < n; j++) {
var temp = "" ;
temp += s[i];
temp += s[j];
if (freq.has(temp))
freq.set(temp, freq.get(temp)+1)
else
freq.set(temp, 1)
}
}
var answer = -1000000000;
freq.forEach((value, key) => {
answer = Math.max(answer, value);
});
return answer;
}
var s = "xxxyy" ;
document.write( maximumOccurrence(s));
</script>
|
Time Complexity: O(N2), for using two nested loops.
Auxiliary Space: O(N), where N is the size of the given string.
Efficient Approach: The idea is to use the dynamic programming paradigm to compute the frequency of the subsequences of lengths 1 and 2 in the string. Below is an illustration of the steps:
- Compute the frequency of the characters of the string in a frequency array.
- For subsequences of the string of length 2, the DP state will be
dp[i][j] = Total number of times ith
character occurred before jth character.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumOccurrence(string s)
{
int n = s.length();
int freq[26] = { 0 };
int dp[26][26] = { 0 };
for ( int i = 0; i < n; i++) {
int c = (s[i] - 'a' );
for ( int j = 0; j < 26; j++)
dp[j] += freq[j];
freq++;
}
int answer = INT_MIN;
for ( int i = 0; i < 26; i++)
answer = max(answer, freq[i]);
for ( int i = 0; i < 26; i++) {
for ( int j = 0; j < 26; j++) {
answer = max(answer, dp[i][j]);
}
}
return answer;
}
int main()
{
string s = "xxxyy" ;
cout << maximumOccurrence(s);
return 0;
}
|
Java
class GFG{
static int maximumOccurrence(String s)
{
int n = s.length();
int freq[] = new int [ 26 ];
int dp[][] = new int [ 26 ][ 26 ];
for ( int i = 0 ; i < n; i++) {
int c = (s.charAt(i) - 'a' );
for ( int j = 0 ; j < 26 ; j++)
dp[j] += freq[j];
freq++;
}
int answer = Integer.MIN_VALUE;
for ( int i = 0 ; i < 26 ; i++)
answer = Math.max(answer, freq[i]);
for ( int i = 0 ; i < 26 ; i++) {
for ( int j = 0 ; j < 26 ; j++) {
answer = Math.max(answer, dp[i][j]);
}
}
return answer;
}
public static void main(String[] args)
{
String s = "xxxyy" ;
System.out.print(maximumOccurrence(s));
}
}
|
Python3
import sys
def maximumOccurrence(s):
n = len (s)
freq = [ 0 ] * ( 26 )
dp = [[ 0 for i in range ( 26 )]
for j in range ( 26 )]
for i in range (n):
c = ( ord (s[i]) - ord ( 'a' ))
for j in range ( 26 ):
dp[j] + = freq[j]
freq + = 1
answer = - sys.maxsize
for i in range ( 26 ):
answer = max (answer, freq[i])
for i in range ( 26 ):
for j in range ( 26 ):
answer = max (answer, dp[i][j])
return answer
if __name__ = = '__main__' :
s = "xxxyy"
print (maximumOccurrence(s))
|
C#
using System;
class GFG{
static int maximumOccurrence( string s)
{
int n = s.Length;
int []freq = new int [26];
int [,]dp = new int [26, 26];
for ( int i = 0; i < n; i++)
{
int x = (s[i] - 'a' );
for ( int j = 0; j < 26; j++)
dp[x, j] += freq[j];
freq[x]++;
}
int answer = int .MinValue;
for ( int i = 0; i < 26; i++)
answer = Math.Max(answer, freq[i]);
for ( int i = 0; i < 26; i++)
{
for ( int j = 0; j < 26; j++)
{
answer = Math.Max(answer, dp[i, j]);
}
}
return answer;
}
public static void Main( string [] args)
{
string s = "xxxyy" ;
Console.Write(maximumOccurrence(s));
}
}
|
Javascript
<script>
function maximumOccurrence(s) {
var n = s.length;
var freq = Array(26).fill(0);
var dp = Array(26).fill().map(()=>Array(26).fill(0));
for ( var i = 0; i < n; i++) {
var c = (s.charCodeAt(i) - 'a' .charCodeAt(0));
for ( var j = 0; j < 26; j++)
dp[j] += freq[j];
freq++;
}
var answer = Number.MIN_VALUE;
for ( var i = 0; i < 26; i++)
answer = Math.max(answer, freq[i]);
for ( var i = 0; i < 26; i++) {
for ( var j = 0; j < 26; j++) {
answer = Math.max(answer, dp[i][j]);
}
}
return answer;
}
var s = "xxxyy" ;
document.write(maximumOccurrence(s));
</script>
|
Time complexity: O(26 * N)
Auxiliary space: O(1) as constant space is required by the algorithm.
Last Updated :
05 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...