[LeetCode] 49. Group Anagrams

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Example 1:

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

Example 2:

Input: strs = [""]
Output: [[""]]

Example 3:

Input: strs = ["a"]
Output: [["a"]] 

Constraints:

• 1 <= strs.length <= 104
• 0 <= strs[i].length <= 100
• strs[i] consists of lower-case English letters.

字母异位词分组。

给定一个字符串数组，将字母异位词组合在一起。可以按任意顺序返回结果列表。字母异位词指字母相同，但排列不同的字符串。

做这个题之前，需要做如下几个题，对anagram的概念有所了解。

242. Valid Anagram

383. Ransom Note

387. First Unique Character in a String

此题比较粗暴的解法是把 input 里面所有的单词都按照字母排序，形成一个新的单词。比如"eat"排序后会成为"aet"，然后以"aet"为key，"eat"为 value 加入 hashmap。遍历完 input 之后，输出 hashmap 所有的 value 即可。

时间O(nlogn) - sort

空间O(n) - hashmap

JavaScript实现

/**
 * @param {string[]} strs
 * @return {string[][]}
 */
var groupAnagrams = function (strs) {
    const map = {};
    for (let str of strs) {
        const key = [...str].sort().join('');
        if (!map[key]) {
            map[key] = [];
        }
        map[key].push(str);
    }
    return Object.values(map);
};

Java实现

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        // corner case
        if (strs == null || strs.length == 0) {
            return new ArrayList<List<String>>();
        }

        // normal case
        HashMap<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] ca = str.toCharArray();
            Arrays.sort(ca);
            String keyStr = String.valueOf(ca);
            if (!map.containsKey(keyStr)) {
                map.put(keyStr, new ArrayList<String>());
            }
            map.get(keyStr).add(str);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

但是如上不是最优解，最优解还是要通过counting sort的思路来做。对于每个单词，需要创建一个长度为26的数组（题目说了只有小写）来存这个单词里面每个字母都分别出现过几次。这样每个单词最后形成的数组会长类似这样，

[ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ]

[ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ]

[ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ]

然后把这个数组稍微变化一下，做成一个类似这样的string

1#0#0#0#1#0#0#0#0#0#0#0#0#0#0#0#0#0#0#1#0#0#0#0#0#0

把这个string当做hashmap的key。这样每个扫描过的单词都会变成这样，是错位词的单词们的string会长得一样，所以在hashmap中会被存到同一个key里面。最后以数组形式输出hashmap里面所有的value即可。或者中间不加#也能做，只需要把charArray convert成string即可，把这个string当做key存入hashmap。

时间O(n) - 没有排序

空间O(n)

JavaScript实现

/**
 * @param {string[]} strs
 * @return {string[][]}
 */
var groupAnagrams = function (strs) {
    const map = new Map();
    for (const s of strs) {
        const letters = Array(26).fill(0);
        for (const c of s) {
            letters[c.charCodeAt(0) - 97]++;
        }
        console.log(letters);
        const key = letters.join("#");
        console.log(key);
        let val = [];
        if (map.has(key)) {
            val = map.get(key);
        }
        val.push(s);
        map.set(key, val);
    }

    return Array.from(map.values());
};

Java实现

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        // corner case
        if (strs == null || strs.length == 0) {
            return new ArrayList<>();
        }

        // normal case
        HashMap<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] ca = new char[26];
            for (char c : str.toCharArray()) {
                ca[c - 'a']++;
            }
            String key = String.valueOf(ca);
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            map.get(key).add(str);
        }
        return new ArrayList<>(map.values());
    }
}

LeetCode 题目总结