4.2：《剑指offer》面试题33：变位词组

题目：

给定一组单词，请将它们按照变位词分组。例如：["eat"，"tea"，"tan"，"ate"，"nat"，"bat"]，这组单词可以分成3组，分别是["eat"，"tea"，"ate"]、["tan"，"nat"]和["bat"]。假设单词中只包含英文小写字母。

算法思路：

方法一：利用质数的性质（质数相乘结果的分解还是几个质数）

具体做法：将每个英文小写字母映射到一个质数，使得每个单词都可以算出一个数字，对于变位词而言，它们算出的这个数字的大小是相等的。例如：单词'eat'->1562(11×2×71)

问题：当单词特别的长的时候，算出的结果可能溢出。

方法二：将单词的字母进行排序。

具体做法：对于读取的每一个字符串先按相同的规则排序，将互为变位词的单词映射到同一个单词。

代码实现：

方法一：

int groupAnagramsF(string s[],int n)
{
    int hash[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
     43,47, 53, 59, 61, 67,71, 73, 79, 83, 89, 97, 101};

    unordered_map<unsigned long, vector<string>> hashmap;

    for (int i = 0; i < n;i++)
    {
        unsigned long key = 1;
        for (int j = 0; j < s[i].size();j++)
        {
            key *= hash[s[i][j] - 'a'];
        }
        
        if(hashmap.find(key)==hashmap.end())
        {
            vector<string> v;
            v.push_back(s[i]);
            hashmap[key] = v;
        }
        else
            hashmap[key].push_back(s[i]);

    }

    return hashmap.size();
}

复杂度分析：

假设输入n个单词，平均每个单词有m个字母，时间复杂度：O(mn)

方法二：

int groupAnagramsS(string s[],int n)
{
    unordered_map<string, vector<string>> hashmap;
    for (int i = 0; i < n;i++)
    {
        string tmp = s[i];
        sort(s[i].begin(), s[i].end());
        if (hashmap.find(s[i]) == hashmap.end())
        {
            vector<string> v;
            v.push_back(tmp);
            hashmap[s[i]] = v;
        }
        else
            hashmap[s[i]].push_back(tmp);
    }

    return hashmap.size();
}

复杂度分析：

假设输入n个单词，平均每个单词有m个字母，使用sort()函数排序的时间复杂度：O(mlogm)，为n个单词排序的时间复杂度：O(nmlogm)。

全部代码：

#include<iostream>
#include<string>
#include<vector>
#include<unordered_map>
#include<algorithm>
using namespace std;

int groupAnagramsF(string s[],int n)
{
    int hash[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
     43,47, 53, 59, 61, 67,71, 73, 79, 83, 89, 97, 101};

    unordered_map<unsigned long, vector<string>> hashmap;

    for (int i = 0; i < n;i++)
    {
        unsigned long key = 1;
        for (int j = 0; j < s[i].size();j++)
        {
            key *= hash[s[i][j] - 'a'];
        }
        
        if(hashmap.find(key)==hashmap.end())
        {
            vector<string> v;
            v.push_back(s[i]);
            hashmap[key] = v;
        }
        else
            hashmap[key].push_back(s[i]);

    }

    return hashmap.size();
}


int groupAnagramsS(string s[],int n)
{
    unordered_map<string, vector<string>> hashmap;
    for (int i = 0; i < n;i++)
    {
        string tmp = s[i];
        sort(s[i].begin(), s[i].end());
        if (hashmap.find(s[i]) == hashmap.end())
        {
            vector<string> v;
            v.push_back(tmp);
            hashmap[s[i]] = v;
        }
        else
            hashmap[s[i]].push_back(tmp);
    }

    return hashmap.size();
}


int main()
{
    string s[6] = {"eat", "tea", "tan", "ate", "nat", "bat"};

    cout << groupAnagramsF(s, 6) << endl;

    cout << groupAnagramsS(s, 6) << endl;
    system("pause");
}

总结：

今天学到了一招：利用质数的性质去识别特定的单词。