【LeetCode - Java】17. 电话号码的字母组合（中等）

1. 题目描述

2. 解题思路

看到这道题的第一反应就是：先不管它，穷举出来再算！在数字2到6中，起数字与对应的字母都是有规律的，对应的字母都是3个，而开头字母与数字的ascii关系是(char - '2') * 3 + 'a'，那7、8和9怎么办呢？似乎只能进行特殊判断了。ok，一个重点解决了，那如何进行这个字符串的构建呢，不就是排列组合嘛，咋们就一层一层来，这时候我想到了似乎可以用StringBuilder进行字符串构建，但后来又一想好像不太行，一层一层构建时字符串数量是呈递增状态（例如先是“a”，“b”和“c”到“ae”，“af”，“ag”，“be”…），无法确定需要的StringBuilder数量。仔细想想，我每一层所生成的字符串都与上一层有关的，因此可以使用一个队列，把上一层的字符串弹出加工后再重新放回队列中。

上述方法可行，但是效率不太高，于是我在想这是不是因为2到9与英文字母的不规律对应判断浪费了时间呢？因此就使用映射表试试全部写出来对应关系，反正也才8个，这里我猜大部分都是想着用HashMap搭建的，但在之前的做题经验中发现数组可以比HashMap更快，因此这里采用了数组构建映射表。

整个算法写完之后发现时间效率也好像不高，会不会是队列频繁增删的问题呢？再瞅了一眼代码，咦，这不就是熟悉的BFS广度优先搜索的影子吗？换言之，这道题还可以使用DFS来做，而DFS构建答案字符串长度是呈递增状态，因此是可以使用StringBuilder进行生成，并且可以省去队列结构，是一种更优的实现。

3. 代码实现

3.1 不构建映射表

public List<String> letterCombinations(String digits) {
        LinkedList<String> linkedList = new LinkedList<>();
        if (digits.length() > 0) {
            char[] chars = digits.toCharArray();
            char first = (char) findFirst(chars[0])[0];
            int count = findFirst(chars[0])[1];
            for (int i = 0; i < count; i++) {
                linkedList.addLast(String.valueOf(first++));
            }
            for (int i = 1; i < chars.length; i++) {
                count = core(linkedList, count, (char) findFirst(chars[i])[0]);
                System.out.println(count);
            }
        }
        return linkedList;
    }

    public int core(LinkedList<String> linkedList, int count, char first) {
        int loop = 3;
        if (first == 'p' || first == 'w')
            loop = 4;
        for (int j = 0; j < count; j++) {
            String pop = linkedList.removeFirst();
            for (int k = 0; k < loop; k++) {
                linkedList.addLast(pop + first++);
            }
            first -= loop;
        }
        return count*loop;
    }

    public int[] findFirst(char c) {
        char first = (char) ((c - '2') * 3 + 'a');
        int count = 3;
        switch (c) {
            case '7':
                count++;
                break;
            case '8':
                first = 't';
                break;
            case '9':
                first = 'w';
                count++;
        }
        return new int[]{first, count};
    }

3.2 构建映射表-BFS

public List<String> letterCombinations(String digits) {
        LinkedList<String> linkedList = new LinkedList<>();
        String[] mapper = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        if (digits.length() > 0) {
            char[] chars = digits.toCharArray();
            linkedList.addLast("");
            int count = 1;
            for (char aChar : chars) {
                char[] chars1 = mapper[aChar - '2'].toCharArray();
                for (int i = 0; i < count; i++) {
                    String s = linkedList.removeFirst();
                    for (char c : chars1) {
                        linkedList.addLast(s + c);
                    }
                }
                count *= chars1.length;
            }
        }
        return linkedList;
    }

3.3 构建映射表-DFS

public LinkedList<String> linkedList = new LinkedList<>();
    StringBuilder sb = new StringBuilder();
    public static String[] mapper = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

    public List<String> letterCombinations(String digits) {
        if (digits.length() > 0)
            dfs(digits, 0);
        return linkedList;
    }

    public void dfs(String digits, int index) {
        if (index == digits.length()) {
            linkedList.add(sb.toString());
            return;
        }
        String s = mapper[digits.charAt(index) - '2'];
        System.out.println(s);
        for (int i = 0; i < s.length(); i++) {
            sb.append(s.charAt(i));
            dfs(digits, index+1);
            sb.deleteCharAt(index);
        }
    }

3.4 对比

其实这道题目的本质还是穷举，穷举出所有可能的组合，因此三种算法的时间复杂度都是O($3^m$+$4^n$) ，其中不构建映射表和BFS两种算法都是需要队列辅助生成结果的，涉及到队列的增删操作，而DFS是直接使用StringBuilder进行构建，不存在大规模的增删操作，因此在相同时间复杂度的情况下DFS算法是更优的。

除了返回数组所占用空间以外，不构建映射表不需要使用额外空间，因此其空间复杂度是O(1)，构建映射表所占用的空间是常数级别的，因此BFS算法的空间复杂度也是O(1)，而DFS算法需要依靠栈进行迭代，迭代的层数就是输入字符串的长度，因此其空间复杂度是O(n)。