LeetCode – Letter Combinations of a Phone Number (Java)

by

Given a digit string, return all possible letter combinations that the number could represent. (Check out your cellphone to see the mappings) Input:Digit string “23”, Output: [“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].

Java Solution 1 – DFS

This problem can be solves by a typical DFS algorithm. DFS problems are very similar and can be solved by using a simple recursion.

public List<String> letterCombinations(String digits) {
    HashMap<Character, char[]> dict = new HashMap<Character, char[]>();
    dict.put('2',new char[]{'a','b','c'});
    dict.put('3',new char[]{'d','e','f'});
    dict.put('4',new char[]{'g','h','i'});
    dict.put('5',new char[]{'j','k','l'});
    dict.put('6',new char[]{'m','n','o'});
    dict.put('7',new char[]{'p','q','r','s'});
    dict.put('8',new char[]{'t','u','v'});
    dict.put('9',new char[]{'w','x','y','z'});
 
    List<String> result = new ArrayList<String>();
    if(digits==null||digits.length()==0){
        return result;
    }
 
    char[] arr = new char[digits.length()];
    helper(digits, 0, dict, result, arr);
 
    return result;
}
 
private void helper(String digits, int index, HashMap<Character, char[]> dict, 
                        List<String> result, char[] arr){
    if(index==digits.length()){
        result.add(new String(arr));
        return;
    }
 
    char number = digits.charAt(index);
    char[] candidates = dict.get(number);
    for(int i=0; i<candidates.length; i++){
        arr[index]=candidates[i];
        helper(digits, index+1, dict, result, arr);
    }
}

Time complexity is O(k^n), where k is the biggest number of letters a digit can map (k=4) and n is the length of the digit string.

Java Solution 2 – BFS

public List<String> letterCombinations(String digits) {
    HashMap<Character, String> map = new HashMap<>();
    map.put('2', "abc");
    map.put('3', "def");
    map.put('4', "ghi");
    map.put('5', "jkl");
    map.put('6', "mno");
    map.put('7', "pqrs");
    map.put('8', "tuv");
    map.put('9', "wxyz");
 
    List<String> l = new ArrayList<>();
    if (digits == null || digits.length() == 0) {
        return l;
    }
 
    l.add("");
 
    for (int i = 0; i < digits.length(); i++) {
        ArrayList<String> temp = new ArrayList<>();
        String option = map.get(digits.charAt(i));
 
        for (int j = 0; j < l.size(); j++) {
            for (int p = 0; p < option.length(); p++) {
                temp.add(new StringBuilder(l.get(j)).append(option.charAt(p)).toString());
            }
        }
 
        l.clear();
        l.addAll(temp);
    }
 
    return l;
}

7 thoughts on “LeetCode – Letter Combinations of a Phone Number (Java)”

  2. I think it’s not O(n^n) but O(m^n) where m is max number of letters possible for one digit and n is number of digits, so in case of keypad it’s O(4^n)

  3. I think it’s O(n^n) n = number of digits
    and space is O(m) m= number of unique combinations for every recursive calls

Leave a Comment