leetcode -- Anagrams

Given an array of strings, return all groups of strings that are anagrams.

Note: All inputs will be in lower-case.

Input:　　["tea","and","ate","eat","den"]

Output:   ["tea","ate","eat"]

["",""]------------->["",""]

["","",""]---------->["","",""]

["tea","and","ate","eat","dan"]------------>["and","dan","tea","ate","eat"]

TLE

public ArrayList<String> anagrams(String[] strs) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int len = strs.length;
        
        Map<Integer, String> sorted = new HashMap<Integer, String>();
        
        sortStrs(strs, sorted, len);
        ArrayList<String> result = new ArrayList<String>();
        boolean[] added = new boolean[len];
        for(int i = 0; i < len; i++)
            added[i] = false;
        
        for(int i = 0; i < len; i++){
            String tmp = sorted.get(i);
            boolean find = false;
            for(int j = i + 1; j < len; j++){
                if(!added[j] && tmp.equals(sorted.get(j))){
                    result.add(strs[j]);
                    added[j] = true;
                    find = true;
                }
            }
            if(!added[i] && find){
                result.add(strs[i]);
                added[i] = true;
                //return result;
            }
        }
        return result;
    }
    
    public void sortStrs(String[] strs, Map<Integer, String> sorted, int len){
        for(int i =0; i < len; i++){
            String s = strs[i];
            char[] c = s.toCharArray();
            Arrays.sort(c);
            sorted.put(i, new String(c));
        }
    }

Solution and Precautions:

First, note what is Anagrams, you can google search it and let’s claim that word A and B is called anagram to each other if we can get word B(A) from A(B)  by rearranging the letters of A(B) to produce B(A), using all the original letters exactly once.

Then, one straightforward way is to compare each pair of words and to see if they are anagrams, my first try is just like this, starting from the first word, I search through all the remaining words and get its corresponding anagrams (to the first word), of course, all such anagrams we found for the first word won’t be anagrams to any other words so we don’t have to consider them for further check. This method could pass the small data set test but will get TLE for large dataset test. The time complexity is O(N^2 * K log K) where N is the number of words and K is the length of the longest word, or you may say the average length of the words.

Finally, if we think deeper into this, we will find that we actually don’t have to do the N^2 comparisons at all. The key observation is that A and B is anagram to each other if and only if their sorted form are exactly the same. As a result, one linear scan through the words list is enough, for each word we can get its sorted form in K log K time, and we can use map to store the groups of words which are in the same sorted form. The time complexity is O(N K log K), this approach could pass both small data test and large data test.

public class Solution {
    public ArrayList<String> anagrams(String[] strs) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int len = strs.length;
        ArrayList<String> result = new ArrayList<String>();
        Map<String, ArrayList<String>> sorted = new HashMap<String, ArrayList<String>>();
        
        for(int i = 0; i < len; i++){
            String tmp = strs[i];
            String sort = sortStr(tmp);
            if(sorted.get(sort) != null){
                sorted.get(sort).add(tmp);
            } else {
                ArrayList<String> list = new ArrayList<String>();
                list.add(tmp);
                sorted.put(sort, list);
            }
        }
        
        Iterator iter = sorted.values().iterator();
        while(iter.hasNext()){
            ArrayList<String> list = (ArrayList<String>)iter.next();
            if(list.size() > 1){
                result.addAll(list);
            }
        }
        
        return result;
    }
    
    public String sortStr(String str){
        char[] c = str.toCharArray();
        Arrays.sort(c);
        return new String(c);
    }
}