[LintCode] Anagrams

Given an array of strings, return all groups of strings that are anagrams.  All inputs will be in lower case.

What is Anagram?
- Two strings are anagram if they can be the same after change the order of characters.

Example

Given ["lint", "intl", "inlt", "code"], return ["lint", "inlt", "intl"].

Given ["ab", "ba", "cd", "dc", "e"], return ["ab", "ba", "cd", "dc"].

Solution 1. Brute Force

The most straightforward solution is to from left to right, fix a string, and compare it with all the remaining

not-added strings on its right side. (By checking only the strings on its right side, we avoid the possiblity of

adding duplicate strings.)If found any anagrams, add this string and its anagrams to the result list and mark

them as added. Repeat this until we've checked all strings.

This solution is not efficient, with a runtime of O(n^2 * k), where n is the number of strings, k is the average 

length of each string.

Solution 2. 

For a string and all its possible anagram strings, we have k! different permutations. (assuming only distinct characters for simplicity)

For a group of anagrams, if we fix one order, say ascending by sorting, we will only have to scan through the input list of strings 

once.

1. Create a hash map. Its keys are the ascending order of a string, its values are a list of all the anagrams of its keys.

2. For each string, sort it, use this sorted string as key and add the unsorted string to the list of anagrams strings.

3. Scan through the hash map and add all lists that have more than 1 string to the final result.

This solution has a O(n * k * log k) runtime and O(n) space usage.

public class Solution {
    public List<String> anagrams(String[] strs) {
        List<String> result = new ArrayList<String>();
        if(strs == null || strs.length == 0){
            return result;
        }
        HashMap<String, ArrayList<String>> hashmap = new HashMap<String, ArrayList<String>>();
        for(String s : strs){
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String sortedStr = String.valueOf(chars);
            if(hashmap.containsKey(sortedStr)){
                hashmap.get(sortedStr).add(s);
            }
            else{
                ArrayList<String> list = new ArrayList<String>();
                list.add(s);
                hashmap.put(sortedStr, list);
            }
        }
        for(String s : hashmap.keySet()){
            ArrayList<String> list = hashmap.get(s);
            if(list.size() > 1){
                result.addAll(list);    
            }
        }
        return result;
    }
}

Related Problems

Strings Homomorphism

Substring Anagrams

Two Strings Are Anagrams