Length of the largest substring which have character with frequency greater than or equal to half of the substring
Given a string S consisting of characters from ‘a’ to ‘z’. The task is to find the length of the largest substring of S which contains a character whose frequency in the sub-string is greater than or equal to half of the length of the substring.
Note: For odd-length substring, to calculate half-length consider integer division. For example, half of 11 is 5.
Examples:
Input : S = "ababbbacbcbcca"
Output : 13
Substring from index 1(0-based indexing) to index 13,
"babbbacbcbcca" have b's frequency equals to 6 which is
equal to half of the length of substring (13/2 = 6).
Input : S = "abcde"
Output : 3
Simple Approach: The idea is to find all the substring of S and for each substring find the frequency of each character and compare it with half of the length of the substring. Now, among all substrings satisfying the condition, the output is the length of the one having the largest length.
Efficient Approach:
First, observe there can be only 26 distinct characters in the string S. So, consider each character one by one for having a frequency greater than or equal to the length of the substring.
So, to find the length of the longest possible sub-string which satisfies the condition, for each character we will make the prefix array of the count of the character. For example, for S = “abacdaef”, the prefix array for ‘a’ will be, say freq[], [1, 1, 2, 2, 2, 3, 3, 3].
We are looking for the following conditions to satisfy:
freq[r] - freq[l - 1] >= (r - l)/2, where l, r are the indices.
Also, we can write,
(2 * freq[r]) - r >= (2 * freq[l - 1]) - l
So, find two arrays r[] and l[], where r[i] = (2 * freq[i]) – i and l[i] = (2 * freq[l – 1]) – l, for 1 <= i <= length of S.
Now, for every i in r[], find the lower bound in l[] using binary search such that the index is minimum in l[], say j.
So, i – j + 1 is one of the solutions. Find the maximum one.
Then loop the above method for each character.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxLength(string s, int n)
{
int ans = INT_MIN;
vector< int > A, L, R;
int freq[n + 5];
for ( int i = 0; i < 26; i++) {
int count = 0;
memset (freq, 0, sizeof freq);
for ( int j = 0; j < n; j++) {
if (s[j] - 'a' == i)
count++;
freq[j] = count;
}
for ( int j = 0; j < n; j++) {
L.push_back((2 * freq[j - 1]) - j);
R.push_back((2 * freq[j]) - j);
}
int max_len = INT_MIN;
int min_val = INT_MAX;
for ( int j = 0; j < n; j++) {
min_val = min(min_val, L[j]);
A.push_back(min_val);
int l = 0, r = j;
while (l <= r) {
int mid = (l + r) >> 1;
if (A[mid] <= R[j]) {
max_len = max(max_len, j - mid + 1);
r = mid - 1;
}
else {
l = mid + 1;
}
}
}
ans = max(ans, max_len);
A.clear();
R.clear();
L.clear();
}
return ans;
}
int main()
{
string s = "ababbbacbcbcca" ;
int n = s.length();
cout << maxLength(s, n) << '\n' ;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maxLength(String s, int n)
{
int ans = Integer.MIN_VALUE;
Vector<Integer> A = new Vector<Integer>();
Vector<Integer> L = new Vector<Integer>();
Vector<Integer> R = new Vector<Integer>();
int []freq = new int [n + 5 ];
for ( int i = 0 ; i < 26 ; i++)
{
int count = 0 ;
for ( int j = 0 ; j < n; j++)
{
if (s.charAt(j) - 'a' == i)
count++;
freq[j] = count;
}
for ( int j = 1 ; j < n; j++)
{
L.add(( 2 * freq[j - 1 ]) - j);
R.add(( 2 * freq[j]) - j);
}
int max_len = Integer.MIN_VALUE;
int min_val = Integer.MAX_VALUE;
for ( int j = 0 ; j < L.size(); j++)
{
min_val = Math.min(min_val, L.get(j));
A.add(min_val);
int l = 0 , r = j;
while (l <= r)
{
int mid = (l + r) >> 1 ;
if (A.get(mid) <= R.get(j))
{
max_len = Math.max(max_len,
j - mid + 1 );
r = mid - 1 ;
}
else
{
l = mid + 1 ;
}
}
}
ans = Math.max(ans, max_len);
A.clear();
R.clear();
L.clear();
}
return ans;
}
public static void main(String[] args)
{
String s = "ababbbacbcbcca" ;
int n = s.length();
System.out.println(maxLength(s, n));
}
}
|
Python3
import sys
def maxLength(s, n) :
ans = - (sys.maxsize + 1 );
A, L, R = [], [], [];
freq = [ 0 ] * (n + 5 );
for i in range ( 26 ) :
count = 0 ;
for j in range (n) :
if ( ord (s[j]) - ord ( 'a' ) = = i) :
count + = 1 ;
freq[j] = count;
for j in range (n) :
L.append(( 2 * freq[j - 1 ]) - j);
R.append(( 2 * freq[j]) - j);
max_len = - (sys.maxsize + 1 );
min_val = sys.maxsize ;
for j in range (n) :
min_val = min (min_val, L[j]);
A.append(min_val);
l = 0 ; r = j;
while (l < = r) :
mid = (l + r) >> 1 ;
if (A[mid] < = R[j]) :
max_len = max (max_len, j - mid + 1 );
r = mid - 1 ;
else :
l = mid + 1 ;
ans = max (ans, max_len);
A.clear();
R.clear();
L.clear();
return ans;
if __name__ = = "__main__" :
s = "ababbbacbcbcca" ;
n = len (s);
print (maxLength(s, n));
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int maxLength(String s, int n)
{
int ans = int .MinValue;
List< int > A = new List< int >();
List< int > L = new List< int >();
List< int > R = new List< int >();
int []freq = new int [n + 5];
for ( int i = 0; i < 26; i++)
{
int count = 0;
for ( int j = 0; j < n; j++)
{
if (s[j] - 'a' == i)
count++;
freq[j] = count;
}
for ( int j = 1; j < n; j++)
{
L.Add((2 * freq[j - 1]) - j);
R.Add((2 * freq[j]) - j);
}
int max_len = int .MinValue;
int min_val = int .MaxValue;
for ( int j = 0; j < L.Count; j++)
{
min_val = Math.Min(min_val, L[j]);
A.Add(min_val);
int l = 0, r = j;
while (l <= r)
{
int mid = (l + r) >> 1;
if (A[mid] <= R[j])
{
max_len = Math.Max(max_len,
j - mid + 1);
r = mid - 1;
}
else
{
l = mid + 1;
}
}
}
ans = Math.Max(ans, max_len);
A.Clear();
R.Clear();
L.Clear();
}
return ans;
}
public static void Main(String[] args)
{
String s = "ababbbacbcbcca" ;
int n = s.Length;
Console.WriteLine(maxLength(s, n));
}
}
|
Javascript
<script>
function maxLength(s, n) {
var ans = -2147483648;
var A = [];
var L = [];
var R = [];
var freq = new Array(n + 5).fill(0);
for ( var i = 0; i < 26; i++) {
var count = 0;
for ( var j = 0; j < n; j++) {
if (s[j].charCodeAt(0) - "a" .charCodeAt(0) === i)
count++;
freq[j] = count;
}
for ( var j = 1; j < n; j++) {
L.push(2 * freq[j - 1] - j);
R.push(2 * freq[j] - j);
}
var max_len = -2147483648;
var min_val = 2147483648;
for ( var j = 0; j < L.length; j++) {
min_val = Math.min(min_val, L[j]);
A.push(min_val);
var l = 0,
r = j;
while (l <= r) {
var mid = (l + r) >> 1;
if (A[mid] <= R[j]) {
max_len = Math.max(max_len, j - mid + 1);
r = mid - 1;
}
else {
l = mid + 1;
}
}
}
ans = Math.max(ans, max_len);
A = [];
R = [];
L = [];
}
return ans;
}
var s = "ababbbacbcbcca" ;
var n = s.length;
document.write(maxLength(s, n));
</script>
|
Time Complexity: O(26*N*logN)
Auxiliary Space: O(1)
Last Updated :
03 Nov, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...