Alien Dictionary

public class Solution {
    public String alienOrder(String[] words) {
        if (words.length == 0) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        Map<Character, Integer> degrees = new HashMap<>();
        Map<Character, Set<Character>> letters = new HashMap<>();
        
        for (String word : words) {
            for (char c : word.toCharArray()) {
                degrees.put(c, 0);
            }
        }
        
        for (int i = 0; i < words.length - 1; i++) {
            for (int j = 0; j < Math.min(words[i].length(), words[i+1].length()); j++) {
                char c1 = words[i].charAt(j);
                char c2 = words[i+1].charAt(j);
                
                if (c1 != c2) {
                    if (!letters.containsKey(c1)) {
                        letters.put(c1, new HashSet<>());
                    }
                    Set<Character> set = letters.get(c1);
                    if (!set.contains(c2)) {
                        set.add(c2);
                        letters.put(c1, set);
                        degrees.put(c2, degrees.get(c2) + 1);
                    }
                    break;
                }
            }
        }
        
        Queue<Character> queue = new LinkedList<>();
        for (char c : degrees.keySet()) {
            if (degrees.get(c) == 0) {
                queue.offer(c);
            }
        }
        
        while (!queue.isEmpty()) {
            char c = queue.poll();
            result.append(c);
            if (letters.containsKey(c)) {
                for (char cSub : letters.get(c)) {
                    degrees.put(cSub, degrees.get(cSub) - 1);
                    if (degrees.get(cSub) == 0) {
                        queue.offer(cSub);
                    }
                }
            }
        }
        
        return result.length() == degrees.size() ? result.toString() : "";
    }
}