17. Letter Combinations of a Phone Number

题目:

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

Input:Digit string "23"
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

Note:
Although the above answer is in lexicographical order, your answer could be in any order you want.

链接：

题解：

也是backtracking，跟permutation一类很像。这次是对每个数字对应的字符进行回溯。  Time Complexity ~ O(3ⁿ), Space Compelxity - O(n);

public class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> res = new ArrayList();
        if(digits == null || digits.length() == 0)
            return res;
        StringBuilder sb = new StringBuilder();
        String[] map = {"", "","abc","def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        dfs(res, sb, digits, map, 0);
        return res;
    }
    
    private void dfs(List<String> res, StringBuilder sb, String digits, String[] map, int pos) {
        if(pos == digits.length()) {
            res.add(sb.toString());
            return;
        }  
        int num = digits.charAt(pos) - '0';
        String str = map[num];
        
        for(int i = 0; i < str.length(); i++) {
            sb.append(str.charAt(i));
            dfs(res, sb, digits, map, pos + 1);
            sb.deleteCharAt(sb.length() - 1);
        }
    }
}

二刷：

比较容易的dfs + backtracking。就是在遍历digits的同时对每个数字可能代表的字符做回溯。也有相应的BFS version，放在reference里

这里复杂度的计算主要参考了UBC AI课程的lecture notes。假设DFS的 path深度是n，branching factor是m那么DFS的Time Complexity 就是 O(b^m)， Space Complexity为 O(bm)。 而对相同的图， BFS的Time Complexity也是O(b^m)， Space Complexity则为 O(b^m)。

When is DFS appropriate? space is restricted solutions tend to occur at the same depth in the tree you know how to order nodes in the list of neighbours so that solutions will be found relatively quickly

When is DFS inappropriate? some paths have infinite length the graph contains cycles some solutions are very deep, while others are very shallow

When is BFS appropriate? space is not a problem it’s necessary to find the solution with the fewest arcs although all solutions may not be shallow, at least some are there may be infinite paths

When is BFS inappropriate? space is limited all solutions tend to be located deep in the tree the branching factor is very large

Java:

Time Complexity - O(3ⁿ)， Space Complexity - O(n)。

public class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> res = new ArrayList<>();
        if (digits == null || digits.length() == 0) {
            return res;
        }
        char[][] map = new char[10][0];
        map[2] = new char[] {'a', 'b', 'c'};
        map[3] = new char[] {'d', 'e', 'f'};
        map[4] = new char[] {'g', 'h', 'i'};
        map[5] = new char[] {'j', 'k', 'l'};
        map[6] = new char[] {'m', 'n', 'o'};
        map[7] = new char[] {'p', 'q', 'r', 's'};
        map[8] = new char[] {'t', 'u', 'v'};
        map[9] = new char[] {'w', 'x', 'y', 'z'};
        StringBuilder sb = new StringBuilder();
        letterCombinations(res, sb, map, digits, 0);
        return res;
    }
    
    private void letterCombinations(List<String> res, StringBuilder sb, char[][] map, String digits, int pos) {
        if (pos == digits.length()) {
            res.add(sb.toString());
            return;
        }
        int num = digits.charAt(pos) - '0';
        for (int j = 0; j < map[num].length; j++) {
            sb.append(map[num][j]);
            letterCombinations(res, sb, map, digits, pos + 1);
            sb.setLength(sb.length() - 1);
        }
    }
}

Python:

class Solution(object):
    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        if not digits:
            return []
        dict = {}
        dict[2] = ['a', 'b', 'c']
        dict[3] = ['d', 'e', 'f']
        dict[4] = ['g', 'h', 'i']
        dict[5] = ['j', 'k', 'l']
        dict[6] = ['m', 'n', 'o']
        dict[7] = ['p', 'q', 'r', 's']
        dict[8] = ['t', 'u', 'v']
        dict[9] = ['w', 'x', 'y', 'z']
        res = []
        list = ''
        self.helper(res, list, dict, digits, 0)
        return res
        
    def helper(self, res, list, dict, digits, pos):
        if pos == len(digits):
            res.append(list)
            return
        num = int(digits[pos])
        for c in dict[num]:
            list += c
            self.helper(res, list, dict, digits, pos + 1)
            list = list[:-1]
        
            
        

  

三刷:

Java:

DFS + Backtracking:

Time Complexity - O(3ⁿ)， Space Complexity - O(n)。

public class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> res = new ArrayList<>();
        if (digits == null || digits.length() == 0) return res;
        String[] map = new String[] {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        getLetterCombinations(res, new StringBuilder(), map, digits, 0);
        return res;
    }
    
    private void getLetterCombinations(List<String> res, StringBuilder sb, String[] map, String digits, int pos) {
        if (pos == digits.length()) {
            res.add(sb.toString());
            return;
        }
        int index = digits.charAt(pos) - '0';
        String letters = map[index];
        for (int i = 0; i < letters.length(); i++) {
            sb.append(letters.charAt(i));
            getLetterCombinations(res, sb, map, digits, pos + 1);
            sb.setLength(sb.length() - 1);
        }
    }
}

BFS:

解答来自Discuss区的lirensun

public class Solution {
    public List<String> letterCombinations(String digits) {
        LinkedList<String> res = new LinkedList<>();
        if (digits == null || digits.length() == 0) return res;
        String[] map = new String[] {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        res.add("");
        for (int i = 0; i < digits.length(); i++) {
            int index = digits.charAt(i) - '0';
            while (res.peek().length() == i) {
                String t = res.remove();
                for (char c : map[index].toCharArray()) {
                    res.add(t + c);
                }
            }
        }
        return res;
    }
}

Reference:

https://www.cs.ubc.ca/~kevinlb/teaching/cs322%20-%202008-9/Lectures/Search3.pdf

https://leetcode.com/discuss/24431/my-java-solution-with-fifo-queue