Leetcode 49. 字母异位词分组

题目

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

说明：

• 所有输入均为小写字母。
• 不考虑答案输出的顺序。

解答

解法一：字符串排序做键

对每个字符串数组里的字符串先按字典序排序，那么具有相同字符的字符串就会映射到同一个字符串。

算法简单，最容易想到，同时也是一个此种类型的题目通用解法。

复杂度：O(nmlogm) 时间，O(nm) 空间 。

代码

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for(int i = 0; i < strs.length; i ++) {
            String cur = strs[i];
            char[] arr = cur.toCharArray();
            Arrays.sort(arr);
            String key = new String(arr);
            
            if(!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            
            map.get(key).add(cur);
        }
    
        return new ArrayList<>(map.values());
    }
}

结果

解法二：计数补#

因为题目要求字符串内只会出现 a - z 的小写字母，说明所有字符都是已知的，就可以采用字符计数的方式让键唯一。

方法：

1. 维护一个长度为 26 的数组作为计数数组。
2. 对当前字符串计数，得到每个字符的个数。
3. 每个位置之间增加一个 # 作为分隔符。

可以看出：拥有相同组成的字符串，字符顺序不同不会对最终的键产生影响，而是会映射到同一个键。

例如：

• abbce - > 1#2#1#0#1#…
• bbace - > 1#2#1#0#1#…

从执行效率上看出：此方法在大数据量，字符串长度很长的时候很占优势。但在小数据量情况下有劣势。

复杂度：O(nm) 时间，O(nm) 空间 。

代码

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for(int i = 0; i < strs.length; i ++) {
            int[] freq = new int[26];
            for(int j = 0; j < strs[i].length(); j ++) {
                freq[strs[i].charAt(j) - 'a'] ++;
            }
            
            StringBuilder stb = new StringBuilder("");
            for (int j = 0; j < 26; j ++) {
                stb.append(freq[j]).append("#");
            }
            
            String key = stb.toString();
            if(!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            
            map.get(key).add(strs[i]);
        }
    
        return new ArrayList<>(map.values());
    }
}

结果

解法三：质数拆分

借鉴了一个大神的代码：传送门

主要思想是：正整数的唯一分解定理。

本质上与解法二类似：都是将相同组成但不同顺序的元素映射到同一位置。

例如：

• abc - > 2 * 3 * 5 = 30
• bac - > 3 * 2 * 5 = 30

缺点是乘法可能会产生溢出，优点是速度很快。这个解法属实牛逼。。。

复杂度：O(nm) 时间，O(nm) 空间 。

代码

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        int[] primes = { 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, List<String>> map = new HashMap<>();
        for(int i = 0; i < strs.length; i ++) {
            int key = 1;
            for (int j = 0; j < strs[i].length(); j ++) {
                key *= primes[strs[i].charAt(j) - 'a'];
            } 

            if(!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            
            map.get(key).add(strs[i]);
        }
    
        return new ArrayList<>(map.values());
    }
}

结果

扩展解法：分而治之

只是想到了这种解法，但是此解法在本题并不占优势，一个尝试而已。

因而只是放在了扩展解法处，有兴趣的同学可以看看。

主要思想还是分治那一套：

1. 确定边界返回值。
2. 确定中点，递归左部分，再递归右部分。
3. 融合左右两部分的结果。

效率不怎么样。分析发现可能是递归的过程有一些重复运算以及一些多余空间的开辟。

复杂度：O(mnlogn) 时间，O(nm) 空间。

代码

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if(strs == null || strs.length == 0) return new ArrayList<>();
        return new ArrayList<>(merge(strs, 0, strs.length - 1).values());
    }
    
    private Map<String, List<String>> merge(String[] strs, int start, int end) {
        if(start == end) {
            Map<String, List<String>> map = new HashMap<>();
            char[] chars = strs[start].toCharArray();
            Arrays.sort(chars);
            map.put(new String(chars), new ArrayList<>(Arrays.asList(strs[start])));
            return map;
        }
        
        int mid = (start + end) >>> 1;
        Map<String, List<String>> left = merge(strs, start, mid);
        Map<String, List<String>> right = merge(strs, mid + 1, end);
        
        return mergeList(left, right);
    }
    
    private Map<String, List<String>> mergeList(Map<String, List<String>> map1, Map<String, List<String>> map2) {
        for(String k1 : map1.keySet()) {
            if(map2.containsKey(k1)) {
                map2.get(k1).addAll(map1.get(k1));
            } else {
                map2.put(k1, map1.get(k1));
            }
        }
        
        return map2;
    }
}

结果