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

2021年5月14日16:20:53 发表评论 889 次浏览

## C ++

``````// C++ Program to implement the
// above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find strings from A[]
// having all strings in B[] as subsequence
void UniversalSubset(vector<string> A, vector<string> B)
{
// Calculate respective sizes
int n1 = A.size();
int n2 = B.size();

vector<string> 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<string> A = { "geeksforgeeks" , "topcoder" , "leetcode" };
vector<string> 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<String> A, List<String> B)
{

// Calculate respective sizes
int n1 = A.size();
int n2 = B.size();

List<String> 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
}

// 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<String> A = Arrays.asList( "geeksforgeeks" , "topcoder" , "leetcode" );
List<String> 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)

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<String> A, List<String> B)
{

// Calculate respective sizes
int n1 = A.Count;
int n2 = B.Count;

List<String> res = new List<String>();

// 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
}

// 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<String> A = new List<String>();

List<String> B = new List<String>();

UniversalSubset(A, B);
}
}

// This code is contributed by amal kumar choubey``````

``geeksforgeeks``