给定两个阵列A []和B []组成的字符串，该任务是打印从数组A []中具有B中的所有字符串[]作为亚序列中的字符串。
例子：
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.
天真的方法：
解决问题的最简单方法是遍历数组A []，对于每个字符串，检查数组B []中的所有字符串是否都作为子字符串于数组中。
时间复杂度： O(N 2 * L)，其中length表示数组A []中字符串的最大长度
辅助空间： O(1)
高效方法：
要优化上述方法，请按照以下步骤操作：
- 初始化矩阵A_fre [] [] ，其中A_fre [i]存储第i个字符串中每个字符的频率。
- 初始化B_fre []以将所有字符的频率存储在数组B []中的字符串中。
- 遍历数组A []并针对每个字符串，检查数组B []的字符串中的字符是否比A []中的第i个字符串的出现频率更高，即
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[].那么该字符串在B []中至少有一个字符串，而不是其子序列。
- 如果不满足A []中任何字符串的所有字符的上述条件，请将该字符串打印为答案。
- 检查所有字符串在A之后[]，如果没有找到字符串被具有在B中的所有字符串[]作为它的适当子集，打印-1。
下面是上述方法的实现：
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][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].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[26] = { 0 };
for (int i = 0; i < n2; i++) {
int arr[26] = { 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 SinghC#
// 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[26];
for(int i = 0; i < n2; i++)
{
int[] arr = new int[26];
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 输出：
geeksforgeeks
时间复杂度： O(N * * L)，其中length表示数组A []中字符串的最大长度。
辅助空间： O(N)