Leetcode49. Group Anagrams
Leetcode49. Group Anagrams
Given an array of strings, group anagrams together.
Note:
- All inputs will be in lowercase.
- The order of your output does not matter.
Example:
Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
Output:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
题目描述：给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
解法一 排序数组分类
思路：当且仅当它们的排序字符串相等时，两个字符串是字母异位词。
算法：维护一个映射 ans : {String -> List}，其中每个键 K 是一个排序字符串，每个值是初始输入的字符串列表，排序后等于 K。在 Java 中将键存储为字符串，例如，code。 在 Python 中，我们将键存储为散列化元组，例如，(‘c’, ‘o’, ‘d’, ‘e’)
- 时间复杂度：排序的话算作
O(Klog(K)),最外层的 for 循环，所以就是O(NKlog(K))。 - 空间复杂度：
O(NK)，用来存储结果。
Python
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
d = {
}
for w in strs:
key = tuple(sorted(w))
d[key] = d.get(key, []) + [w]
return list(d.values())
① tuple(sorted(w))：sort()无返回值，sorted()返回排序好的列表；将其转为tuple因为字典的key必须是immutable，不能是列表；tuple()会将字符串abc变为元组('a', 'b', 'c')，key是元组类型。
② d[key] = d.get(key, []) + [w]：d.get(key, [])取字典中键为key的值，如果值不在字典则返回[]，然后将原字符串w加入字典中key对应的值。
③ 以列表的形式返回字典所有的值。
④判断是否异位的方法是将每个字符串按字母表排序后，如果相同则为异位。
⑤思路：将一组字符串的每一个元素先排序后作为字典的key，向空字典中加入元素，元素排序后的值为key，元素本来的值作为value。
class Solution(object):
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
ans = collections.defaultdict(list)#避免发生KeyError异常
for s in strs:
ans[tuple(sorted(s))].append(s)
return ans.values()
Java
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
if (strs.length == 0) return new ArrayList();
Map<String, List> ans = new HashMap<String, List>();
for (String s : strs) {
char[] ca = s.toCharArray();
Arrays.sort(ca);
String key = String.valueOf(ca);
if (!ans.containsKey(key)) ans.put(key, new ArrayList());
ans.get(key).add(s);
}
return new ArrayList(ans.values());
}
}
解法二 按计数分类
思路：当且仅当它们的字符计数（每个字符的出现次数）相同时，两个字符串是字母异位词。
算法：我们可以将每个字符串 s 转换为字符数 count，由26个非负整数组成，表示 a，b，c 的数量等。我们使用这些计数作为哈希映射的基础。在 Java 中，我们的字符数 count 的散列化表示将是一个用 ＃ 字符分隔的字符串。 例如，abbccc 将表示为 ＃1＃2＃3＃0＃0＃0 …＃0，其中总共有26个条目。 在 python 中，表示将是一个计数的元组。 例如，abbccc 将表示为 (1,2,3,0,0，…，0)，其中总共有 26 个条目。
- 时间复杂度：
O(NK)。 - 空间复杂度：
O(NK)，用来存储结果。
Python
class Solution:
def groupAnagrams(strs):
ans = collections.defaultdict(list)
for s in strs:
count = [0] * 26
for c in s:
count[ord(c) - ord('a')] += 1
ans[tuple(count)].append(s)
return ans.values()
Java
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
if (strs.length == 0) return new ArrayList();
Map<String, List> ans = new HashMap<String, List>();
int[] count = new int[26];
for (String s : strs) {
Arrays.fill(count, 0);
for (char c : s.toCharArray()) count[c - 'a']++;
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < 26; i++) {
sb.append('#');
sb.append(count[i]);
}
String key = sb.toString();
if (!ans.containsKey(key)) ans.put(key, new ArrayList());
ans.get(key).add(s);
}
return new ArrayList(ans.values());
}
}
解法三 利用算术基本定理
算术基本定理，又称为正整数的唯一分解定理，即：每个大于1的自然数，要么本身就是质数，要么可以写为2个以上的质数的积，而且这些质因子按大小排列之后，写法仅有一种方式。
利用这个，我们把每个字符串都映射到一个正数上。
用一个数组存储质数 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}。
然后每个字符串的字符减去 ’ a ’ ，然后取到 prime 中对应的质数。把它们累乘。
例如 abc ，就对应 ‘a’ - ‘a’， ‘b’ - ‘a’， ‘c’ - ‘a’，即 0, 1, 2，也就是对应素数 2 3 5，然后相乘 2 3 5 = 30，就把 “abc” 映射到了 30。
public List<List<String>> groupAnagrams(String[] strs) {
HashMap<Integer, List<String>> hash = new HashMap<>();
//每个字母对应一个质数
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 };
for (int i = 0; i < strs.length; i++) {
int key = 1;
//累乘得到 key
for (int j = 0; j < strs[i].length(); j++) {
key *= prime[strs[i].charAt(j) - 'a'];
}
if (hash.containsKey(key)) {
hash.get(key).add(strs[i]);
} else {
List<String> temp = new ArrayList<String>();
temp.add(strs[i]);
hash.put(key, temp);
}
}
return new ArrayList<List<String>>(hash.values());
}