哈希表题目：单词子集

题目

标题和出处

标题：单词子集

出处：916. 单词子集

难度

4 级

题目描述

要求

给你两个字符串数组 $\text{words1}$ 和 $\text{words2}$。

如果 $\text{b}$ 中的每个字母都出现在 $\text{a}$ 中，包括重复出现的字母，那么称字符串 $\text{b}$ 是字符串 $\text{a}$ 的子集。

• 例如，$\text{"wrr"}$ 是 $\text{"warrior"}$ 的子集，但不是 $\text{"world"}$ 的子集。

对 $\text{words1}$ 中的单词 $\text{a}$，如果对 $\text{words2}$ 中的每一个单词 $\text{b}$，$\text{b}$ 都是 $\text{a}$ 的子集，那么我们称 $\text{a}$ 是通用单词。

以数组形式返回 $\text{words1}$ 中所有的通用单词。你可以按任意顺序返回答案。

示例

示例 1：

输入：$\text{words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["e","o"]}$
输出：$\text{["facebook","google","leetcode"]}$

示例 2：

输入：$\text{words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["l","e"]}$
输出：$\text{["apple","google","leetcode"]}$

数据范围

• $\text{1}\le \text{words1.length, words2.length}\le {\text{10}}^{\text{4}}$
• $\text{1}\le \text{words1[i].length, words2[i].length}\le \text{10}$
• $\text{words1[i]}$ 和 $\text{words2[i]}$ 仅由小写英语字母组成
• $\text{words1}$ 中的所有字符串互不相同

解法

思路和算法

数组 ${\text{words}}_1$ 中的单词 $\text{word}$ 是通用单词，等价于单词 $\text{word}$ 中的每个字母的出现次数都不小于数组 ${\text{words}}_2$ 中的任意一个单词中的相同字母的出现次数。

最直观的做法是，首先统计出数组 ${\text{words}}_2$ 中的每个单词中的每个字母的出现次数，然后遍历数组 ${\text{words}}_1$，对于每个单词 $a$，遍历数组 ${\text{words}}_2$ 中的每个单词 $b$，判断单词 $a$ 中的每个字母的出现次数是否都不小于单词 $b$ 中的相同字母的出现次数。假设数组 ${\text{words}}_1$ 和 ${\text{words}}_2$ 的长度分别是 $m$ 和 $n$，则上述做法的时间复杂度至少为 $O(mn)$，由于 $m$ 和 $n$ 的最大值可达 $10^4$，因此上述做法的时间复杂度过高，需要优化。

由于通用单词中的每个字母的出现次数不小于数组 ${\text{words}}_2$ 中的任意一个单词中的相同字母的出现次数，因此只需要记录每个字母在数组 ${\text{words}}_2$ 中的单词中的最大出现次数即可，通用单词中的每个字母的出现次数不小于相同字母在数组 ${\text{words}}_2$ 中的单词中的最大出现次数。

首先遍历数组 ${\text{words}}_2$ 中的每个单词，并记录每个字母在数组 ${\text{words}}_2$ 中的单词中的最大出现次数，然后遍历数组 ${\text{words}}_1$ 中的每个单词 $\text{word}$，根据单词 $\text{word}$ 中的每个字母的出现次数是否都不小于相同字母在数组 ${\text{words}}_2$ 中的单词中的最大出现次数，判断单词 $\text{word}$ 是不是通用单词，将通用单词添加到结果列表。

实现方面，由于数组 ${\text{words}}_1$ 和 ${\text{words}}_2$ 中的每个单词只包含小写英语字母，因此可以使用长度为 $26$ 的数组代替哈希表记录每个字母的出现次数。

代码

class Solution {
    public List<String> wordSubsets(String[] words1, String[] words2) {
        int[] unionCounts = new int[26];
        for (String word : words2) {
            int[] letterCounts = getLetterCounts(word);
            for (int i = 0; i < 26; i++) {
                unionCounts[i] = Math.max(unionCounts[i], letterCounts[i]);
            }
        }
        List<String> subsets = new ArrayList<String>();
        for (String word : words1) {
            boolean isUniversal = true;
            int[] letterCounts = getLetterCounts(word);
            for (int i = 0; i < 26; i++) {
                if (letterCounts[i] < unionCounts[i]) {
                    isUniversal = false;
                    break;
                }
            }
            if (isUniversal) {
                subsets.add(word);
            }
        }
        return subsets;
    }

    public int[] getLetterCounts(String word) {
        int[] letterCounts = new int[26];
        int length = word.length();
        for (int i = 0; i < length; i++) {
            char c = word.charAt(i);
            letterCounts[c - 'a']++;
        }
        return letterCounts;
    }
}

复杂度分析

• 时间复杂度：$O(L_1+L_2+|\Sigma |\times (m+n))$，其中 $m$ 和 $n$ 分别是数组 ${\text{words}}_1$ 和 ${\text{words}}_2$ 的长度，$L_1$ 和 $L_2$ 分别是数组 ${\text{words}}_1$ 和 ${\text{words}}_2$ 中的单词长度之和，$\Sigma$ 是字符集，这道题中 $\Sigma$ 是全部小写英语字母，$|\Sigma |=26$。
  首先需要遍历数组 ${\text{words}}_2$ 中的全部单词并记录每个字母的最大出现次数，需要 $O(L_2+|\Sigma |\times n)$ 的时间。
  然后需要遍历数组 ${\text{words}}_1$ 中的全部单词并判断每个单词是不是通用单词，需要 $O(L_1+|\Sigma |\times m)$ 的时间。
  因此总时间复杂度是 $O(L_1+L_2+|\Sigma |\times (m+n))$。

• 空间复杂度：$O(|\Sigma |)$，其中 $\Sigma$ 是字符集，这道题中 $\Sigma$ 是全部小写英语字母，$|\Sigma |=26$。空间复杂度主要取决于哈希表，需要使用哈希表记录每个字母在数组 ${\text{words}}_2$ 中的单词中的最大出现次数，以及在遍历数组 ${\text{words}}_1$ 时需要使用哈希表记录遍历到的单词中的每个字母的出现次数。注意返回值不计入空间复杂度。