LeetCode-49. Group Anagrams

Given an array of strings, group anagrams together.

Example:

Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
Output:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

Note:

• All inputs will be in lowercase.
• The order of your output does not matter.

针对每个字符串，和当前所有group的第一个字符串比较，字符串比较使用map，不是最优解。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {//my
        List<List<String>> re = new ArrayList<>();
        for (int i = 0; i < strs.length; i++) {
            if(0==i){
                List<String> group = new ArrayList<>();
                group.add(strs[0]);
                re.add(group);
            }
            else{
                int flag = 0;
                for (int j = 0; j < re.size(); j++) {
                    if(isAnagram(strs[i],re.get(j).get(0))){
                        re.get(j).add(strs[i]);
                        flag= 1;
                    }
                }
                if(0==flag){
                    List<String> group = new ArrayList<>();
                    group.add(strs[i]);
                    re.add(group);
                }
            }
        }
        return re;
    }
    private boolean isAnagram(String s, String t) {
        if(null==s&&null==t){
            return true;
        }
        if(null==s||null==t||s.length()!=t.length()){
            return false;
        }
        Map<Character,Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char c= s.charAt(i);
            if(map.containsKey(c)){
                map.put(c,map.get(c)+1);
            }
            else{
                map.put(c,1);
            }
        }
        for (int i = 0; i < t.length(); i++) {
            char c= t.charAt(i);
            if(map.containsKey(c)){
                map.put(c,map.get(c)-1);
                if(map.get(c)==0){
                    map.remove(c);
                }
            }
            else{
                return false;
            }
        }
        return true;
    }
}

优解思路是为每个group，设置一个唯一的hashcode，即map的key，然后讲字符串映射为哈希值并判断，所以哈希函数的设计决定了算法的时间复杂度，字符串长度为k，字符串个数为n。

• 排序，key为排序后的字符串，但时间复杂度最优为O(nklogk)
• 拼接字符串，key为使用特殊字符分割的26个数字，每个数值表示当前字母出现的次数，如#2#1#0#0...#0表示aab，时间复杂度为O(nk)
• 素数，key为一个整数，每个字母使用一个素数表示，key为每个字母所表示素数的乘积，如12=2*2*3表示aab，时间复杂度为O(nk)

问题的关键是找到一个较优的唯一映射关系。

public List<List<String>> groupAnagrams(String[] strs) {//哈希 map mytip
        List<List<String>> re = new ArrayList<>();
        int[] prime={2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103};//素数代表一个字母
        Map<Integer,Integer> map=new HashMap<>();
        for (int i = 0; i < strs.length; i++) {
            int code = 1;
            for (int j = 0; j < strs[i].length(); j++) {
                code*=prime[strs[i].charAt(j)-'a'];
            }
            if(map.containsKey(code)){
                re.get(map.get(code)).add(strs[i]);
            }
            else {
                List<String> group = new ArrayList<>();
                group.add(strs[i]);
                map.put(code,re.size());
                re.add(group);
            }
        }
        return re;
    }
    

相关题

有效的字母异位词 LeetCode242 https://www.cnblogs.com/zhacai/p/10574647.html

进阶题

查找所有异位词 LeetCode438 https://www.cnblogs.com/zhacai/p/10596274.html