Related Articles
Print all Strings from array A[] having all strings from array B[] as subsequence
• Last Updated : 20 Aug, 2020

Given two arrays A[] and B[] consisting of strings, the task is to print the strings from array A[] having all strings in B[] as a subsequence.
Examples:

Input: A[] = {“geeksforgeeks”, “mapple”, “twitter”, “table”, “Linkedin”}, B[] = {“e”, “l”}
Output: mapple table linkedin
Explanation: Both the strings “e” and “l” are subsets in “mapple”, “table”, “linkedin”.

Input: A[] = {“geeksforgeeks”, “topcoder”, “leetcode”}, B[] = {“geek”, “ee”}
Output: geeksforgeeks
Explanation: Each string in B[], {“geek”, “ee”} occurs in “geeksforgeeks” only.

Naive Approach:
The simplest approach to solve the problem is to traverse array A[] and for every string, check if all the strings in array B[] are present in it as a subsequence or not.

Time complexity: O(N2 * L), where length denotes the maximum length of a string in array A[]
Auxiliary Space: O(1)

Efficient Approach:
To optimize the above approach, follow the steps below:

• Initialize a matrix A_fre[][], in which A_fre[i] stores the frequency of each character in ith string.
• Initialize B_fre[] to store frequency of all characters in the strings in array B[].
• Traverse over array A[] and for every string, check if a character has more frequency in the strings of array B[] than in ith string in A[], i.e.

if A_fre[i][j] < B_fre[j], where
A_fre[i][j]: Frequency of the character with ASCII value (‘a’ + j) in ith string in A[]
B_fre[j]: Frequency of the character with ASCII value (‘a’ + j) in the strings of B[].

then that string has at least one string in B[] which is not its subsequence.

• If the above condition is not satisfied for all characters for any string in A[], print that string as an answer.
• After checking all strings in A[], if no string is found to be having all strings in B[] as its proper subset, print -1.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the``// above approach``#include ``using` `namespace` `std;`` ` `// Function to find strings from A[]``// having all strings in B[] as subsequence``void` `UniversalSubset(vector A,``                     ``vector B)``{``    ``// Calculate respective sizes``    ``int` `n1 = A.size();``    ``int` `n2 = B.size();`` ` `    ``// Stores the answer``    ``vector res;`` ` `    ``// Stores the frequency of each``    ``// character in strings of A[]``    ``int` `A_fre[n1];`` ` `    ``for` `(``int` `i = 0; i < n1; i++) {``        ``for` `(``int` `j = 0; j < 26; j++)``            ``A_fre[i][j] = 0;``    ``}`` ` `    ``// Compute the frequencies``    ``// of characters of all strings``    ``for` `(``int` `i = 0; i < n1; i++) {``        ``for` `(``int` `j = 0; j < A[i].size();``             ``j++) {``            ``A_fre[i][A[i][j] - ``'a'``]++;``        ``}``    ``}`` ` `    ``// Stores the frequency of each``    ``// character in strings of B[]``    ``// each character of a string in B[]``    ``int` `B_fre = { 0 };`` ` `    ``for` `(``int` `i = 0; i < n2; i++) {``        ``int` `arr = { 0 };``        ``for` `(``int` `j = 0; j < B[i].size();``             ``j++) {`` ` `            ``arr[B[i][j] - ``'a'``]++;``            ``B_fre[B[i][j] - ``'a'``]``                ``= max(B_fre[B[i][j] - ``'a'``],``                      ``arr[B[i][j] - ``'a'``]);``        ``}``    ``}`` ` `    ``for` `(``int` `i = 0; i < n1; i++) {``        ``int` `flag = 0;``        ``for` `(``int` `j = 0; j < 26; j++) {`` ` `            ``// If the frequency of a character``            ``// in B[] exceeds that in A[]``            ``if` `(A_fre[i][j] < B_fre[j]) {`` ` `                ``// A string exists in B[] which``                ``// is not a proper subset of A[i]``                ``flag = 1;``                ``break``;``            ``}``        ``}`` ` `        ``// If all strings in B[] are``        ``// proper subset of A[]``        ``if` `(flag == 0)``            ``// Push the string in``            ``// resultant vector``            ``res.push_back(A[i]);``    ``}`` ` `    ``// If any string is found``    ``if` `(res.size()) {`` ` `        ``// Print those strings``        ``for` `(``int` `i = 0; i < res.size();``             ``i++) {``            ``for` `(``int` `j = 0; j < res[i].size();``                 ``j++)``                ``cout << res[i][j];``        ``}`` ` `        ``cout << ``" "``;``    ``}`` ` `    ``// Otherwise``    ``else``        ``cout << ``"-1"``;``}`` ` `// Driver code``int` `main()``{``    ``vector A = { ``"geeksforgeeks"``,``                         ``"topcoder"``,``                         ``"leetcode"` `};``    ``vector B = { ``"geek"``, ``"ee"` `};`` ` `    ``UniversalSubset(A, B);`` ` `    ``return` `0;``}`

## Java

 `// Java program to implement ``// the above approach ``import` `java.util.*;`` ` `class` `GFG {``     ` `// Function to find strings from A[] ``// having all strings in B[] as subsequence ``static` `void` `UniversalSubset(List A, ``                            ``List B) ``{ ``     ` `    ``// Calculate respective sizes ``    ``int` `n1 = A.size(); ``    ``int` `n2 = B.size(); `` ` `    ``// Stores the answer ``    ``List res = ``new` `ArrayList<>(); `` ` `    ``// Stores the frequency of each ``    ``// character in strings of A[] ``    ``int``[][] A_fre = ``new` `int``[n1][``26``]; `` ` `    ``for``(``int` `i = ``0``; i < n1; i++)``    ``{ ``        ``for``(``int` `j = ``0``; j < ``26``; j++) ``            ``A_fre[i][j] = ``0``; ``    ``} `` ` `    ``// Compute the frequencies ``    ``// of characters of all strings ``    ``for``(``int` `i = ``0``; i < n1; i++)``    ``{ ``        ``for``(``int` `j = ``0``; j < A.get(i).length(); j++) ``        ``{ ``            ``A_fre[i][A.get(i).charAt(j) - ``'a'``]++; ``        ``} ``    ``} `` ` `    ``// Stores the frequency of each ``    ``// character in strings of B[] ``    ``// each character of a string in B[] ``    ``int``[] B_fre = ``new` `int``[``26``]; `` ` `    ``for``(``int` `i = ``0``; i < n2; i++)``    ``{ ``        ``int``[] arr = ``new` `int``[``26``] ; ``        ``for``(``int` `j = ``0``; j < B.get(i).length(); j++)``        ``{ ``            ``arr[B.get(i).charAt(j) - ``'a'``]++; ``            ``B_fre[B.get(i).charAt(j) - ``'a'``] = Math.max(``            ``B_fre[B.get(i).charAt(j) - ``'a'``], ``              ``arr[B.get(i).charAt(j) - ``'a'``]); ``        ``} ``    ``} `` ` `    ``for``(``int` `i = ``0``; i < n1; i++)``    ``{ ``        ``int` `flag = ``0``; ``        ``for``(``int` `j = ``0``; j < ``26``; j++) ``        ``{ `` ` `            ``// If the frequency of a character ``            ``// in B[] exceeds that in A[] ``            ``if` `(A_fre[i][j] < B_fre[j])``            ``{ ``                 ` `                ``// A string exists in B[] which ``                ``// is not a proper subset of A[i] ``                ``flag = ``1``; ``                ``break``; ``            ``} ``        ``} `` ` `        ``// If all strings in B[] are ``        ``// proper subset of A[] ``        ``if` `(flag == ``0``) ``         ` `            ``// Push the string in ``            ``// resultant vector ``            ``res.add(A.get(i)); ``    ``} `` ` `    ``// If any string is found ``    ``if` `(res.size() != ``0``)``    ``{ ``         ` `        ``// Print those strings ``        ``for``(``int` `i = ``0``; i < res.size(); i++) ``        ``{ ``            ``for``(``int` `j = ``0``; ``                    ``j < res.get(i).length();``                    ``j++) ``            ``System.out.print(res.get(i).charAt(j)); ``        ``} ``        ``System.out.print(``" "``); ``    ``} `` ` `    ``// Otherwise ``    ``else``    ``System.out.print(``"-1"``); ``}`` ` `// Driver code``public` `static` `void` `main (String[] args) ``{``    ``List A = Arrays.asList(``"geeksforgeeks"``, ``                                   ``"topcoder"``, ``                                   ``"leetcode"``); ``    ``List B = Arrays.asList(``"geek"``, ``"ee"``); ``     ` `    ``UniversalSubset(A, B); ``}``}`` ` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement``# the above approach`` ` `# Function to find strings from A[]``# having all strings in B[] as subsequence``def` `UniversalSubset(A, B):`` ` `    ``# Calculate respective sizes``    ``n1 ``=` `len``(A)``    ``n2 ``=` `len``(B)`` ` `    ``# Stores the answer``    ``res ``=` `[]`` ` `    ``# Stores the frequency of each``    ``# character in strings of A[]``    ``A_freq ``=` `[[``0` `for` `x ``in` `range``(``26``)]``                 ``for` `y ``in` `range``(n1)]`` ` `    ``# Compute the frequencies``    ``# of characters of all strings``    ``for` `i ``in` `range``(n1):``        ``for` `j ``in` `range``(``len``(A[i])):``            ``A_freq[i][``ord``(A[i][j]) ``-` `ord``(``'a'``)] ``+``=` `1`` ` `    ``# Stores the frequency of each``    ``# character in strings of B[]``    ``# each character of a string in B[]``    ``B_freq ``=` `[``0``] ``*` `26`` ` `    ``for` `i ``in` `range``(n2):``        ``arr ``=` `[``0``] ``*` `26``         ` `        ``for` `j ``in` `range``(``len``(B[i])):``            ``arr[``ord``(B[i][j]) ``-` `ord``(``'a'``)] ``+``=` `1``             ` `            ``B_freq[``ord``(B[i][j]) ``-` `ord``(``'a'``)] ``=` `max``(``            ``B_freq[``ord``(B[i][j]) ``-` `ord``(``'a'``)],``               ``arr[``ord``(B[i][j]) ``-` `ord``(``'a'``)])`` ` `    ``for` `i ``in` `range``(n1):``        ``flag ``=` `0``        ``for` `j ``in` `range``(``26``):`` ` `            ``# If the frequency of a character``            ``# in B[] exceeds that in A[]``            ``if``(A_freq[i][j] < B_freq[j]):`` ` `                ``# A string exists in B[] which``                ``# is not a proper subset of A[i]``                ``flag ``=` `1``                ``break`` ` `        ``# If all strings in B[] are``        ``# proper subset of A[]``        ``if``(flag ``=``=` `0``):``             ` `            ``# Push the string in``            ``# resultant vector``            ``res.append(A[i])`` ` `    ``# If any string is found``    ``if``(``len``(res)):`` ` `        ``# Print those strings``        ``for` `i ``in` `range``(``len``(res)):``            ``for` `j ``in` `range``(``len``(res[i])):``                ``print``(res[i][j], end ``=` `"")`` ` `    ``# Otherwise ``    ``else``:``        ``print``(``-``1``, end ``=` `"")`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:`` ` `    ``A ``=` `[ ``"geeksforgeeks"``, ``"topcoder"``, ``          ``"leetcode"` `]``    ``B ``=` `[ ``"geek"``, ``"ee"` `]`` ` `    ``UniversalSubset(A, B)`` ` `# This code is contributed by Shivam Singh`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{`` ` `// Function to find strings from []A``// having all strings in []B as subsequence``static` `void` `UniversalSubset(List A,``                            ``List B)``{``     ` `    ``// Calculate respective sizes``    ``int` `n1 = A.Count;``    ``int` `n2 = B.Count;`` ` `    ``// Stores the answer``    ``List res = ``new` `List();`` ` `    ``// Stores the frequency of each``    ``// character in strings of []A``    ``int``[,] A_fre = ``new` `int``[n1, 26];`` ` `    ``for``(``int` `i = 0; i < n1; i++)``    ``{``        ``for``(``int` `j = 0; j < 26; j++)``            ``A_fre[i, j] = 0;``    ``}`` ` `    ``// Compute the frequencies``    ``// of characters of all strings``    ``for``(``int` `i = 0; i < n1; i++)``    ``{``        ``for``(``int` `j = 0; j < A[i].Length; j++)``        ``{``            ``A_fre[i, A[i][j] - ``'a'``]++;``        ``}``    ``}`` ` `    ``// Stores the frequency of each``    ``// character in strings of []B``    ``// each character of a string in []B``    ``int``[] B_fre = ``new` `int``;`` ` `    ``for``(``int` `i = 0; i < n2; i++)``    ``{``        ``int``[] arr = ``new` `int``;``        ``for``(``int` `j = 0; j < B[i].Length; j++)``        ``{``            ``arr[B[i][j] - ``'a'``]++;``            ``B_fre[B[i][j] - ``'a'``] = Math.Max(``                                   ``B_fre[B[i][j] - ``'a'``],``                                     ``arr[B[i][j] - ``'a'``]);``        ``}``    ``}`` ` `    ``for``(``int` `i = 0; i < n1; i++)``    ``{``        ``int` `flag = 0;``        ``for``(``int` `j = 0; j < 26; j++) ``        ``{``             ` `            ``// If the frequency of a character``            ``// in []B exceeds that in []A``            ``if` `(A_fre[i, j] < B_fre[j])``            ``{``                 ` `                ``// A string exists in []B which``                ``// is not a proper subset of A[i]``                ``flag = 1;``                ``break``;``            ``}``        ``}`` ` `        ``// If all strings in []B are``        ``// proper subset of []A``        ``if` `(flag == 0)`` ` `            ``// Push the string in``            ``// resultant vector``            ``res.Add(A[i]);``    ``}`` ` `    ``// If any string is found``    ``if` `(res.Count != 0)``    ``{``         ` `        ``// Print those strings``        ``for``(``int` `i = 0; i < res.Count; i++)``        ``{``            ``for``(``int` `j = 0; j < res[i].Length; j++)``                ``Console.Write(res[i][j]);``        ``}``        ``Console.Write(``" "``);``    ``}`` ` `    ``// Otherwise``    ``else``        ``Console.Write(``"-1"``);``}`` ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``List A = ``new` `List();``    ``A.Add(``"geeksforgeeks"``);``    ``A.Add(``"topcoder"``);``    ``A.Add(``"leetcode"``);``     ` `    ``List B = ``new` `List();``    ``B.Add(``"geek"``);``    ``B.Add(``"ee"``);`` ` `    ``UniversalSubset(A, B);``}``}`` ` `// This code is contributed by amal kumar choubey`
Output:
```geeksforgeeks
```

Time Complexity: O(N * * L), where length denotes the maximum length of a string in array A[].
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up