打印数组 A[] 中的所有字符串，并将数组 B[] 中的所有字符串作为子序列

给定两个阵列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 ² * 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 i^th 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 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[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

Javascript

  
// Javascript Program to implement the
// above approach
 
// Function to find strings from A[]
// having all strings in B[] as subsequence
function UniversalSubset(A, B)
{
    // Calculate respective sizes
    var n1 = A.length;
    var n2 = B.length;
 
    // Stores the answer
    var res = [];
 
    // Stores the frequency of each
    // character in strings of A[]
    var A_fre = Array.from( Array(n1), ()=> Array(26));
 
    for (var i = 0; i < n1; i++) {
        for (var j = 0; j < 26; j++)
            A_fre[i][j] = 0;
    }
 
    // Compute the frequencies
    // of characters of all strings
    for (var i = 0; i < n1; i++) {
        for (var j = 0; j < A[i].length;
             j++) {
            A_fre[i][A[i].charCodeAt(j) - 'a'.charCodeAt(0)]++;
        }
    }
 
    // Stores the frequency of each
    // character in strings of B[]
    // each character of a string in B[]
    var B_fre = Array(26).fill(0);
 
    for (var i = 0; i < n2; i++) {
        var arr = Array(26).fill(0);
        for (var j = 0; j < B[i].length;
             j++) {
 
            arr[B[i].charCodeAt(j) - 'a'.charCodeAt(0)]++;
            B_fre[B[i].charCodeAt(j) - 'a'.charCodeAt(0)]
                = Math.max(B_fre[B[i].charCodeAt(j) - 'a'.charCodeAt(0)],
                      arr[B[i].charCodeAt(j)- 'a'.charCodeAt(0)]);
        }
    }
 
    for (var i = 0; i < n1; i++) {
        var flag = 0;
        for (var 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(A[i]);
    }
 
    // If any string is found
    if (res.length>0) {
 
        // Print those strings
        for (var i = 0; i < res.length;
             i++) {
            for (var j = 0; j < res[i].length;
                 j++)
                document.write( res[i][j]);
        }
 
        document.write( " ");
    }
 
    // Otherwise
    else
        document.write( "-1");
}
 
// Driver code
var A = ["geeksforgeeks",
                     "topcoder",
                     "leetcode" ];
var B = ["geek", "ee" ];
UniversalSubset(A, B);
 
 

输出：

geeksforgeeks

时间复杂度： O(N * * L)，其中长度表示数组 A[] 中字符串的最大长度。
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live