[LintCode] Word Abbreviation

Given an array of n distinct non-empty strings, you need to generate minimal possible abbreviations for every word following rules below.

1. Begin with the first character and then the number of characters abbreviated, which followed by the last character.
2. If there are any conflict, that is more than one words share the same abbreviation, a longer prefix is used instead of only the first character until making the map from word to abbreviation become unique. In other words, a final abbreviation cannot map to more than one original words.
3. If the abbreviation doesn't make the word shorter, then keep it as original.

 Notice

1. Both n and the length of each word will not exceed 400.
2. The length of each word is greater than 1.
3. The words consist of lowercase English letters only.
4. The return answers should be in the same order as the original array.

Example

Given dict = ["like", "god", "internal", "me", "internet", "interval", "intension", "face", "intrusion"]
return ["l2e","god","internal","me","i6t","interval","inte4n","f2e","intr4n"]


This problem is not hard not algorithmic wise, but implementation wise. To tackle this kind of problem,
going through a good example as simulation is sufficient enough to get the following working algorithm.

1. Create an arraylist that stores not-uniquely mapped string's index.
2. Initialize nonAbbrLen = 2, according to rule 3. 
3. As long as there is still not-uniquely mapped string, repeat the following.

　 a.For each not-uniquely mapped string str, get its next level's abbreviation abbr and 
   store them in (abbr, str's index in dict[]). 

   b.After going through all the strings, add all uniquely mapped strings from 
   the hash map to the final result. 

   c.For all not uniquely mapped strings, add them to a new array list and assign
     this list to unprocessedIndex.

   d.Increase the next abbreviation level by 1 to further distinguish strings that
     currently share the same abbreviation.
  
   e. Repeat until unprocessdIndex is empty.

public class Solution {
    public String[] wordsAbbreviation(String[] dict) {
        if(dict == null || dict.length == 0){
            return new String[0];
        }
        int n = dict.length;
        String[] res = new String[n];
        List<Integer> unprocessedIndex = new ArrayList<Integer>();
        for(int i = 0; i < n; i++){
            unprocessedIndex.add(i);
        }
        int nonAbbrLen = 2;
        while(unprocessedIndex.size() != 0){
            HashMap<String, ArrayList<Integer>> map = new HashMap<String, ArrayList<Integer>>();
            for(int i : unprocessedIndex){
                String curr = dict[i];
                String abbr = curr.length() <= (nonAbbrLen + 1) ?
                              curr : curr.substring(0, nonAbbrLen - 1) + (curr.length() - nonAbbrLen)
                              + curr.charAt(curr.length() - 1);
                if(map.containsKey(abbr)){
                    map.get(abbr).add(i);
                }
                else{
                    ArrayList<Integer> list = new ArrayList<Integer>();
                    list.add(i);
                    map.put(abbr, list);
                }
            }
            List<Integer> next = new ArrayList<Integer>();
            for(String word : map.keySet()){
                if(map.get(word).size() == 1){
                    for(int idx : map.get(word)){
                        res[idx] = word;
                    }
                }
                else{
                    for(int idx : map.get(word)){
                        next.add(idx);
                    }
                }
            }
            unprocessedIndex = next;
            nonAbbrLen++;
        }
        return res;
    }
}

The key point of the above solution is to use hashmap to determine if a certain abbreviation level can uniquely map to 

only one word. If a map key points to a list of size 1, then we know this key uniquely maps to one word.

Related Problems 

Check Word Abbreviation