# Count of Superstrings in a given array of strings

• Difficulty Level : Hard
• Last Updated : 29 Jun, 2021

Given 2 array of strings X and Y, the task is to find the number of superstrings in X.

A string s is said to be a Superstring, if each string present in array Y is a subsequence of string s .

Examples:

Input: X = {“ceo”, “alco”, “caaeio”, “ceai”}, Y = {“ec”, “oc”, “ceo”}
Output: 2
Explanation: Strings “ceo” and “caaeio” are superstrings as each string of array Y is a subset of these 2 strings. Other strings are not included in answer all strings of array Y are not
sub-sets of them.

Input: X = {“iopo”, “oaai”, “iipo”}, Y = {“oo”}
Output: 1

Approach: The idea is to use the concept of Hashing to store the frequencies of characters to solve the problem. Follow the steps below to solve the problem:

• Initialize an array of size 26 to store the maximum occurrences of every character[a-z] in each string present in array Y.
• Now consider each string s in X,
• Check if frequency of every character in s is greater than equal to the frequency obtained from the above step

Below is the implementation of the above approach:

## C++

 `// C++ implementation for the above approach` `#include ``using` `namespace` `std;` `// Function to find total number of superstrings``int` `superstring(string X[], string Y[], ``int` `N, ``int` `M)``{` `    ``// Array to store max frequency``    ``// Of each letter``    ``int` `maxFreq[26];``    ``for` `(``int` `i = 0; i < 26; i++)``        ``maxFreq[i] = 0;` `    ``for` `(``int` `j = 0; j < M; j++) {``        ``int` `temp[26];``        ``for` `(``int` `i = 0; i < 26; i++)``            ``temp[i] = 0;``        ``for` `(``int` `k = 0; k < Y[j].size(); k++) {``            ``temp[Y[j][k] - ``'a'``]++;``        ``}``        ``for` `(``int` `i = 0; i < 26; i++) {``            ``maxFreq[i] = max(maxFreq[i], temp[i]);``        ``}``    ``}` `    ``int` `ans = 0;``    ``for` `(``int` `j = 0; j < N; j++) {` `        ``// Array to find frequency of each letter in string``        ``// x``        ``int` `temp[26];``        ``for` `(``int` `i = 0; i < 26; i++)``            ``temp[i] = 0;``        ``for` `(``int` `k = 0; k < X[j].size(); k++) {``            ``temp[X[j][k] - ``'a'``]++;``        ``}``        ``int` `i = 0;``        ``for` `(i = 0; i < 26; i++) {` `            ``// If any frequency is less in string x than``            ``// maxFreq, then it can't be a superstring``            ``if` `(temp[i] < maxFreq[i]) {``                ``break``;``            ``}``        ``}``        ``if` `(i == 26) {` `            ``// Increment counter of x is a superstring``            ``ans++;``        ``}``    ``}``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``// Size of array X``    ``int` `N = 4;``    ``// Size of array Y``    ``int` `M = 3;` `    ``string X[N] = { ``"ceo"``, ``"alco"``, ``"caaeio"``, ``"ceai"` `};``    ``string Y[M] = { ``"ec"``, ``"oc"``, ``"ceo"` `};` `    ``cout << superstring(X, Y, N, M); ``// Function call``    ``return` `0;``}`

## Java

 `// Java implementation for the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function to find total number of superstrings``    ``public` `static` `int` `superString(String X[], String Y[],``                                  ``int` `N, ``int` `M)``    ``{` `        ``// Array to store max frequency``        ``// Of each letter``        ``int``[] maxFreq = ``new` `int``[``26``];``        ``for` `(``int` `i = ``0``; i < ``26``; i++)``            ``maxFreq[i] = ``0``;` `        ``for` `(``int` `j = ``0``; j < M; j++) {``            ``int``[] temp = ``new` `int``[``26``];``            ``for` `(``int` `k = ``0``; k < Y[j].length(); k++) {``                ``temp[Y[j].charAt(k) - ``'a'``]++;``            ``}``            ``for` `(``int` `i = ``0``; i < ``26``; i++) {``                ``maxFreq[i] = Math.max(maxFreq[i], temp[i]);``            ``}``        ``}` `        ``int` `ans = ``0``;``        ``for` `(``int` `j = ``0``; j < N; j++) {` `            ``// Array to find frequency of each letter in``            ``// string x``            ``int``[] temp = ``new` `int``[``26``];``            ``for` `(``int` `i = ``0``; i < ``26``; i++)``                ``temp[i] = ``0``;``            ``for` `(``int` `k = ``0``; k < X[j].length(); k++) {``                ``temp[X[j].charAt(k) - ``'a'``]++;``            ``}` `            ``int` `i = ``0``;``            ``for` `(i = ``0``; i < ``26``; i++) {` `                ``// If any frequency is less in string x than``                ``// maxFreq, then it can't be a superstring``                ``if` `(temp[i] < maxFreq[i]) {``                    ``break``;``                ``}``            ``}``            ``if` `(i == ``26``) {` `                ``// Increment counter of x is a superstring``                ``ans++;``            ``}``        ``}``        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String[] X = ``new` `String[] { ``"ceo"``, ``"alco"``, ``"caaeio"``,``                                    ``"ceai"` `};``        ``String[] Y = ``new` `String[] { ``"ec"``, ``"oc"``, ``"ceo"` `};` `        ``System.out.println(``            ``superString(X, Y, X.length, Y.length));``    ``}``}`

## Python3

 `# Python3 implementation for the above approach` `# Function to find total number of superstrings``def` `superstring(X, Y, N, M):` `    ``# Array to store max frequency``    ``# Of each letter``    ``maxFreq ``=` `[``0``] ``*` `26` `    ``for` `j ``in` `range``(M):``        ``temp ``=` `[``0``] ``*` `26``        ``for` `k ``in` `range``(``len``(Y[j])):``            ``temp[``ord``(Y[j][k]) ``-` `ord``(``'a'``)] ``+``=` `1``        ``for` `i ``in` `range``(``26``):``            ``maxFreq[i] ``=` `max``(maxFreq[i], temp[i])` `    ``ans ``=` `0``    ``for` `j ``in` `range``(N):``        ` `        ``# Array to find frequency of each letter``        ``# in string x``        ``temp ``=` `[``0``] ``*` `26``        ``for` `k ``in` `range``(``len``(X[j])):``            ``temp[``ord``(X[j][k]) ``-` `ord``(``'a'``)] ``+``=` `1``            ` `        ``i ``=` `0``        ` `        ``while` `i < ``26``:``            ` `            ``# If any frequency is less in x than``            ``# maxFreq, then it can't be a superstring``            ``if` `(temp[i] < maxFreq[i]):``                ``break``            ``i ``+``=` `1``        ``if` `(i ``=``=` `26``):``            ` `            ``# Increment counter of x is a superstring``            ``ans ``+``=` `1` `    ``return` `ans` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Size of array X``    ``N ``=` `4``    ` `    ``# Size of array Y``    ``M ``=` `3` `    ``X ``=` `[``"ceo"``, ``"alco"``, ``"caaeio"``, ``"ceai"``]``    ``Y ``=` `[ ``"ec"``, ``"oc"``, ``"ceo"` `]` `    ``print``(superstring(X, Y, N, M)) ``#Function call` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{` `    ``// Function to find total number of superstrings``    ``public` `static` `int` `superString(``string``[] X, ``string``[] Y,``                                  ``int` `N, ``int` `M)``    ``{` `        ``// Array to store max frequency``        ``// Of each letter``        ``int``[] maxFreq = ``new` `int``[26];``        ``for` `(``int` `i = 0; i < 26; i++)``            ``maxFreq[i] = 0;` `        ``for` `(``int` `j = 0; j < M; j++) {``            ``int``[] temp = ``new` `int``[26];``            ``for` `(``int` `k = 0; k < Y[j].Length; k++) {``                ``temp[Y[j][k] - ``'a'``]++;``            ``}``            ``for` `(``int` `i = 0; i < 26; i++) {``                ``maxFreq[i] = Math.Max(maxFreq[i], temp[i]);``            ``}``        ``}` `        ``int` `ans = 0;``        ``for` `(``int` `j = 0; j < N; j++) {` `            ``// Array to find frequency of each letter in``            ``// string x``            ``int``[] temp = ``new` `int``[26];``            ``int` `i =0;``            ``for` `( i = 0; i < 26; i++)``                ``temp[i] = 0;``            ``for` `(``int` `k = 0; k < X[j].Length; k++) {``                ``temp[X[j][k] - ``'a'``]++;``            ``}` `            ``for` `( i = 0; i < 26; i++) {` `                ``// If any frequency is less in string x than``                ``// maxFreq, then it can't be a superstring``                ``if` `(temp[i] < maxFreq[i]) {``                    ``break``;``                ``}``            ``}``            ``if` `( i == 26) {` `                ``// Increment counter of x is a superstring``                ``ans++;``            ``}``        ``}``        ``return` `ans;``    ``}` `// Driver code``static` `void` `Main()``{``    ``string``[] X = ``new` `String[] { ``"ceo"``, ``"alco"``, ``"caaeio"``,``                                    ``"ceai"` `};``        ``string``[] Y = ``new` `String[] { ``"ec"``, ``"oc"``, ``"ceo"` `};` `        ``Console.Write(``            ``superString(X, Y, X.Length, Y.Length));``}``}` `// This code is contributed b sanjoy_62.`

## Javascript

 ``
Output:
`2`

Time complexity: O(N*N1 + M*M1), where N = size of array X, N1 = Maxlength(x), M = size of array Y, M1 = Maxlength(y),

Space complexity: O(1)

My Personal Notes arrow_drop_up