Number of Positions to partition the string such that atleast m characters with same frequency are present in each substring

10 Jun, 2022
Given a string str of lowercase English alphabets and an integer m. The task is to count how many positions are there in the string such that if you partition the string into two non-empty sub-strings, there are at least m characters with the same frequency in both the sub-strings. The characters need to be present in the string str.Examples:  
Input: str = “aabbccaa”, m = 2 Output: 2 The string has length 8, so there are 7 positions available to perform the partition. i.e. a|a|b|b|c|c|a|a Only two partitions are possible which satisfy the given constraints. aab|bccaa – On the left half of the separator, ‘a’ has frequency 2 and ‘b’ has frequency 1 which is same as that of the right half. aabbc|caa – On the left half of the separator, ‘a’ has frequency 2 and ‘c’ has frequency 1 which is same as that of the right half.Input: str = “aabbaa”, m = 2 Output: 1  
 
Approach: For each partition position, calculate the frequencies of each of the characters of the string in both the partitions. Then calculate the number of characters having same frequency in both partitions. If the count of such characters is at least m then add 1 to the required count of partitions.Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the number of ways// to partition the given so that the// given condition is satisfiedint countWays(string str, int m){    // Hashset to store unique characters    // in the given string    set<char> s;    for (int i = 0; i < str.length(); i++)        s.insert(str[i]);     // To store the number of ways    // to partition the string    int result = 0;     for (int i = 1; i < str.length(); i++)    {        // Hashmaps to store frequency of characters        // of both the partitions        map<char, int> first_map, second_map;         // Iterate in the first partition        for (int j = 0; j < i; j++)             // If character already exists in the hashmap            // then increase it's frequency            first_map[str[j]]++;         // Iterate in the second partition        for (int k = 0; k < str.length(); k++)             // If character already exists in the hashmap            // then increase it's frequency            second_map[str[k]]++;         // Iterator for HashSet        set<char>::iterator itr = s.begin();         // To store the count of characters that have        // equal frequencies in both the partitions        int total_count = 0;        while (++itr != s.end())        {            // first_count and second_count keeps track            // of the frequencies of each character            int first_count = 0, second_count = 0;            char ch = *(itr);             // Frequency of the character            // in the first partition            if (first_map.find(ch) != first_map.end())                first_count = first_map[ch];             // Frequency of the character            // in the second partition            if (second_map.find(ch) != second_map.end())                second_count = second_map[ch];             // Check if frequency is same            // in both the partitions            if (first_count == second_count &&                first_count != 0)                total_count += 1;        }         // Check if the condition is satisfied        // for the current partition        if (total_count >= m)            result += 1;    }    return result;} // Driver codeint main(int argc, char const *argv[]){    string str = "aabbccaa";    int m = 2;    cout << countWays(str, m) << endl;    return 0;} // This code is contributed by// sanjeev2552
// Java implementation of the approachimport java.util.*; class GFG {     // Function to return the number of ways    // to partition the given so that the    // given condition is satisfied    static int countWays(String str, int m)    {         // Hashset to store unique characters        // in the given string        HashSet<Character> set = new HashSet<Character>();        for (int i = 0; i < str.length(); i++)            set.add(str.charAt(i));         // To store the number of ways        // to partition the string        int result = 0;         for (int i = 1; i < str.length(); i++) {             // Hashmaps to store frequency of characters            // of both the partitions            HashMap<Character, Integer> first_map                = new HashMap<Character, Integer>();            HashMap<Character, Integer> second_map                = new HashMap<Character, Integer>();             // Iterate in the first partition            for (int j = 0; j < i; j++) {                 // If character already exists in the hashmap                // then increase it's frequency                if (first_map.containsKey(str.charAt(j)))                    first_map.put(str.charAt(j),                                  (first_map.get(str.charAt(j)) + 1));                 // Else create an entry for it in the Hashmap                else                    first_map.put(str.charAt(j), 1);            }             // Iterate in the second partition            for (int k = i; k < str.length(); k++) {                 // If character already exists in the hashmap                // then increase it's frequency                if (second_map.containsKey(str.charAt(k)))                    second_map.put(str.charAt(k),                                   (second_map.get(str.charAt(k)) + 1));                 // Else create an entry for it in the Hashmap                else                    second_map.put(str.charAt(k), 1);            }             // Iterator for HashSet            Iterator itr = set.iterator();             // To store the count of characters that have            // equal frequencies in both the partitions            int total_count = 0;             while (itr.hasNext()) {                 // first_count and second_count keeps track                // of the frequencies of each character                int first_count = 0, second_count = 0;                char ch = (char)itr.next();                 // Frequency of the character                // in the first partition                if (first_map.containsKey(ch))                    first_count = first_map.get(ch);                 // Frequency of the character                // in the second partition                if (second_map.containsKey(ch))                    second_count = second_map.get(ch);                 // Check if frequency is same in both the partitions                if (first_count == second_count && first_count != 0)                    total_count += 1;            }             // Check if the condition is satisfied            // for the current partition            if (total_count >= m)                result += 1;        }         return result;    }     // Driver code    public static void main(String[] args)    {        String str = "aabbccaa";        int m = 2;        System.out.println(countWays(str, m));    }}
# Python3 implementation of the approachfrom collections import defaultdict # Function to return the number of ways# to partition the given so that the# given condition is satisfieddef countWays(string, m):     # Hashset to store unique    # characters in the given string    Set = set()    for i in range(0, len(string)):        Set.add(string[i])     # To store the number of ways    # to partition the string    result = 0     for i in range(1, len(string)):         # Hashmaps to store frequency of        # characters of both the partitions        first_map = defaultdict(lambda:0)        second_map = defaultdict(lambda:0)         # Iterate in the first partition        for j in range(0, i):             first_map[string[j]] += 1                 # Iterate in the second partition        for k in range(i, len(string)):             second_map[string[k]] += 1                 # To store the count of characters that have        # equal frequencies in both the partitions        total_count = 0         for ch in Set:             # first_count and second_count keeps track            # of the frequencies of each character            first_count, second_count = 0, 0             # Frequency of the character            # in the first partition            if ch in first_map:                first_count = first_map[ch]             # Frequency of the character            # in the second partition            if ch in second_map:                second_count = second_map[ch]             # Check if frequency is same in both the partitions            if first_count == second_count and first_count != 0:                total_count += 1                 # Check if the condition is satisfied        # for the current partition        if total_count >= m:            result += 1         return result # Driver codeif __name__ == "__main__":     string = "aabbccaa"    m = 2    print(countWays(string, m))     # This code is contributed by Rituraj Jain
// C# implementation of the approachusing System;using System.Collections.Generic; public class GFG {      // Function to return the number of ways    // to partition the given so that the    // given condition is satisfied    static int countWays(String str, int m)    {          // Hashset to store unique characters        // in the given string        HashSet<char> set = new HashSet<char>();        for (int i = 0; i < str.Length; i++)            set.Add(str[i]);          // To store the number of ways        // to partition the string        int result = 0;          for (int i = 1; i < str.Length; i++) {              // Hashmaps to store frequency of characters            // of both the partitions            Dictionary<char, int> first_map                = new Dictionary<char, int>();            Dictionary<char, int> second_map                = new Dictionary<char, int>();              // Iterate in the first partition            for (int j = 0; j < i; j++) {                  // If character already exists in the hashmap                // then increase it's frequency                if (first_map.ContainsKey(str[j]))                    first_map[str[j]] =                                  (first_map[str[j]] + 1);                  // Else create an entry for it in the Hashmap                else                    first_map.Add(str[j], 1);            }              // Iterate in the second partition            for (int k = i; k < str.Length; k++) {                  // If character already exists in the hashmap                // then increase it's frequency                if (second_map.ContainsKey(str[k]))                    second_map[str[k]] =                                   (second_map[str[k]] + 1);                  // Else create an entry for it in the Hashmap                else                    second_map.Add(str[k], 1);            }                // To store the count of characters that have            // equal frequencies in both the partitions            int total_count = 0;             // Iterator for HashSet            foreach (int itr in set) {                  // first_count and second_count keeps track                // of the frequencies of each character                int first_count = 0, second_count = 0;                char ch = (char)itr;                  // Frequency of the character                // in the first partition                if (first_map.ContainsKey(ch))                    first_count = first_map[ch];                  // Frequency of the character                // in the second partition                if (second_map.ContainsKey(ch))                    second_count = second_map[ch];                  // Check if frequency is same in both the partitions                if (first_count == second_count && first_count != 0)                    total_count += 1;            }              // Check if the condition is satisfied            // for the current partition            if (total_count >= m)                result += 1;        }          return result;    }      // Driver code    public static void Main(String[] args)    {        String str = "aabbccaa";        int m = 2;        Console.WriteLine(countWays(str, m));    }} // This code is contributed by Rajput-Ji
<script> // Javascript implementation of the approach // Function to return the number of ways// to partition the given so that the// given condition is satisfiedfunction countWays(str, m){    // Hashset to store unique characters    // in the given string    var s = new Set();    for (var i = 0; i < str.length; i++)        s.add(str[i]);     // To store the number of ways    // to partition the string    var result = 0;     for (var i = 1; i < str.length; i++)    {        // Hashmaps to store frequency of characters        // of both the partitions        var first_map = new Map(), second_map = new Map();         // Iterate in the first partition        for (var j = 0; j < i; j++)             // If character already exists in the hashmap            // then increase it's frequency            if(first_map.has(str[j]))                first_map.set(str[j], first_map.get(str[j])+1)            else                first_map.set(str[j], 1)         // Iterate in the second partition        for (var k = 0; k < str.length; k++)             // If character already exists in the hashmap            // then increase it's frequency            if(second_map.has(str[k]))                second_map.set(str[k], second_map.get(str[k])+1)            else                second_map.set(str[k], 1)          // To store the count of characters that have        // equal frequencies in both the partitions        var total_count = 0;        s.forEach(itr => {                         // first_count and second_count keeps track            // of the frequencies of each character            var first_count = 0, second_count = 0;            var ch = itr;             // Frequency of the character            // in the first partition            if (first_map.has(ch))                first_count = first_map.get(ch);             // Frequency of the character            // in the second partition            if (second_map.has(ch))                second_count = second_map.get(ch);             // Check if frequency is same            // in both the partitions            if (first_count == second_count &&                first_count != 0)                total_count += 1;        });         // Check if the condition is satisfied        // for the current partition        if (total_count >= m)            result += 1;    }    return result;} // Driver codevar str = "aabbccaa";var m = 2;document.write( countWays(str, m)); // This code is contributed by itsok.</script>
2
 
Time Complexity: O(n*n*log(n)), as nested loops are used for iterationAuxiliary Space: O(n), as extra space of size n is used to make a set and map
rituraj_jain
Divyank_Sheth
sanjeev2552
Rajput-Ji
itsok
singhh3010
frequency-counting
HashSet
Java 8
Thoughtworks
Hash
Strings
Thoughtworks
Hash
Strings
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
What is Hashing | A Complete Tutorial
Real-time application of Data Structures
Find k numbers with most occurrences in the given array
Find the length of largest subarray with 0 sum
Non-Repeating Element
Write a program to reverse an array or string
Reverse a string in Java
Write a program to print all permutations of a given string
C++ Data Types
Different Methods to Reverse a String in C++