力扣刷题日记

给定一个字符串数组 words，请计算当两个字符串 words[i] 和 words[j] 不包含相同字符时，它们长度的乘积的最大值。假设字符串中只包含英语的小写字母。如果没有不包含相同字符的一对字符串，返回 0。

示例 1:
输入: words = [“abcw”,“baz”,“foo”,“bar”,“fxyz”,“abcdef”]
输出: 16
解释: 这两个单词为 “abcw”, “fxyz”。它们不包含相同字符，且长度的乘积最大。

示例 2:
输入: words = [“a”,“ab”,“abc”,“d”,“cd”,“bcd”,“abcd”]
输出: 4
解释: 这两个单词为 “ab”, “cd”。

示例 3:
输入: words = [“a”,“aa”,“aaa”,“aaaa”]
输出: 0
解释: 不存在这样的两个单词。

提示：
2 <= words.length <= 1000
1 <= words[i].length <= 1000
words[i] 仅包含小写字母

思路1：暴力解法

依次判断两两单词中有无重复字母，若有，继续判断下两个单词；若没有，计算两单词长度的乘积，与现有的最大结果进行比较，并更新结果。

for(int i = 0; i < words.size(); ++i){
	string s1 = words[i];
	for(int j = i + 1; j < words.size(); ++j){
		string s2 = words[j];
		//判断 s1 s2 中有无重复元素, 按照上述思路
	}
}

时间复杂度：O(n² * c²)，c 为 字符串的平均长度；空间复杂度：O(1)。

思路2：巧用二进制

使用 26 位二进制数表示字符串中 26 个小写字母是否出现过，即将字符串转换为二进制数。然后使用与运算，如果两单词中有相同字母，与运算后对应二进制位为 1；否则，对应二进制位为 0。
0 & 0 = 0； 0 & 1 = 0； 1 & 0 = 0； 1 & 1 = 1。

代码如下：

class Solution {
public:
    int maxProduct(vector<string>& words) {
        int size1 = words.size();
        vector<int> v(size1);
        for(int i = 0; i < size1; ++i){ //O(cn)
            for(char ch : words[i])
                v[i] |= 1 << (ch - 'a'); // 右边第一位表示 a 有没有出现
        }
        int ret = 0;
        for(int i = 0; i < size1; ++i){ //O(n^2)
            for(int j = i + 1; j < size1; ++j){
                if(!(v[i] & v[j]))
                    ret = ret > words[i].size() * words[j].size() ? ret : words[i].size() * words[j].size();
            }
        }
        return ret;
    }
};

时间复杂度：O((c + n) * n)，c 为 字符串的平均长度；空间复杂度：O(n)。

思路3：哈希表

哈希表之前讲过，附上链接: 哈希表基础知识

在本题中，哈希表的键值对存储的内容为：键存储单词的二进制表示；值存储单词的长度（若不同单词具有相同二进制表示，如 ab aaaabb aabbbbbb 等，则存储最长的长度）。

class Solution {
public:
    int maxProduct(vector<string>& words) {
        int size = words.size();
        unordered_map<int, int> um; // 键：存储单词的二进制表示; 值：存储最长的单词长度
        for(int i = 0; i < size; ++i){
            int b = 0;
            for(char ch : words[i]) //这个循环把单词转换为整数的二进制表示
                b |= 1 << (ch - 'a'); 
            //如果 um 中存在具有给定键的值 b, 则此函数返回1, 否则返回0
            //不同单词可能会有相同的二进制表示, 如 ab aabbb aaaabb 等, 此时纪录最长单词的长度
            um[b] = um.count(b) ? max(um[b], (int)words[i].size()) : words[i].size();
        }
        int ret = 0;
        for(auto& x : um){
            for(auto& y : um){
                // um.first 代表某个单词的二进制表示, 如果两个单词没有重复字母, 进行 与运算 时结果为 0
                if((x.first & y.first) == 0) 
                    ret = max(ret, x.second * y.second);
            }
        }
        return ret;
    }
};

时间复杂度：O((c + n) * n)，c 为 字符串的平均长度；空间复杂度：O(n)。

该方法速度比第二种稍快些，但是哈希表所用内存比vector数组要大。

这里再给出用二维数组模拟哈希表的解法：

class Solution {
public:
    int maxProduct(vector<string>& words) {
        int size = words.size();
        vector<vector<bool>> vhash(size, vector<bool>(26, false));
        for(int i = 0; i < size; ++i){
            for(char& ch : words[i])
                vhash[i][ch - 'a'] = true;
        }
        int ret = 0;
        for(int i = 0; i < size; ++i){
            for(int j = i + 1; j < size; ++j){
                int k = 0;
                for( ; k < 26; ++k){
                    if(vhash[i][k] & vhash[j][k])
                        break;
                }
                if(k == 26)
                    ret = max(ret, (int)(words[i].size() * words[j].size()));
            }
        }
        return ret;
    }
};