Leetcode 49. Group Anagrams （242.Valid Anagram）

valid Anagram

Given two strings s and t, write a function to determine if t is an anagram of s.

For example,
s = "anagram", t = "nagaram", return true.
s = "rat", t = "car", return false.

Note:
You may assume the string contains only lowercase alphabets.

Follow up:
What if the inputs contain unicode characters? How would you adapt your solution to such case?

1、题目分析

解法一：使用一个数组，将a-z这26个字母的出现情况保存下来。第一个字符串出现的单词加一，第二个字符串出现的单词减一。最后保存26的字母的数组为全0，则两个字符串相等。

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size()!=t.size()){
            return false;
        }
        vector<int> flag(26,0);
        for(int i = 0;i<s.size();i++){
            flag[s[i]%26]++;
            flag[t[i]%26]--;
        }
        for(int i = 0;i<26;i++){
            if(flag[i]!=0){
                return false;
            }
        }
        return true;
    }
};

Anagram group

这个题目要更复杂一些，需要比较多个字符串，并进行分类排序。

Given an array of strings, group anagrams together.

For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"], 
Return:

[
  ["ate", "eat","tea"],
  ["nat","tan"],
  ["bat"]
]

Note:

1. For the return value, each inner list's elements must follow the lexicographic order.
2. All inputs will be in lower-case.

1、题目分析

超时解法：

1、使用sort函数将每个单词进行排序。        O( N*log(m))

2、然后遍历这个字符串数组，申请一个一维整型数组，将相同的单词编上相同的数字。   O(1)

3、申请一个二维数组 vector<vector<string>>把相同编号的单词放到同一个一维数组中。  O(N*logN)

4、对每一个一维数组进行排序。最终返回结果。  O(N)~O(logN)

时间复杂度分析：sort函数采用快速排序实现，假设n个单词，每个单词m个字母。m比较小，n比较大。

从上面的分析可知，2.遍历数组过程中判断某个单词是新单词还是以前出现过的耗时最长。

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        int num = strs.size();
        vector<string> strscopy;
        vector<string> resultLine;
        vector<string> temp;
        vector<int> flag(strs.size(),-1);
        
        strscopy.assign(strs.begin(),strs.end());
        
        //对每个单词排序
        for(int i = 0;i<num;i++){
            sort (strs[i].begin(), strs[i].end()); 
        }
        //sort(strs.begin(),strs.end());
        //使用temp记录相同的元素大类，使用flag记录每个单词摆放的位置。O(m*n)
        for(int i = 0;i<num;i++){
            int tag = -1;
            int j;
            for(j = 0;j<temp.size();j++){
                if(strs[i]==temp[j]){
                    tag = j;
                }
            }
            if(tag!=-1){
                flag[i] = tag;
            }else{
                temp.push_back(strs[i]);
                flag[i] = temp.size()-1;
            }
            tag = -1;
        }
        vector<vector<string>> result(temp.size(),resultLine);
        //O(n)
        for(int i = 0;i<strs.size();i++){
            result[flag[i]].push_back(strscopy[i]);
        }
        //O(m)*O(sort)
        for(int i = 0;i<result.size();i++){
            sort(result[i].begin(),result[i].end());
        }
        return result;

    }
};

改进解法：

使用unordered_map结构来实现单词分类。上述过程改进为

1、使用sort函数将每个单词进行排序。        O( N*log(m))

2、key值保存排完序的单词，value为字符串数组。          

3、对每个单词排序 O(log(N))

  vector<vector<string>> result;
        unordered_map<string, vector<string>> hashmap;
        //使用sort函数对每个单词排序
        for(const auto& i : strs){
            string s = i;
            sort(s.begin(), s.end());
            //使用map结构进行保存
            hashmap[s].push_back(i);
        }
        for(const auto& i : hashmap){
           //i.second表示hashmap的value值
            vector<string> s = i.second;
            sort(s.begin(), s.end());
            result.push_back(s);
        }
        return result;