【Leetcode】17回溯（电话号码的字母组合）

1.题目详情

题目分析

 自己的想法：需要创建哈希表来存储字母和数字的结构。一开始考虑将输入的digits的长度作为变量，发现自己不会回溯。又看到了提示中限定了长度最多有4个。

• 0 <= digits.length <= 4

所以分类讨论了一下=。虽然通过了，但是还是用回溯比较好

`

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        self.hashMap = {2:"abc",3:"def",4:"ghi" ,
                    5:"jkl",6:"mno",7:"pqrs",8:"tuv",9:"wxyz"}
        l = []
        # for i in range(len(str)):
        #     num = int(str[i])
        #     num_zimu_string = hashMap[num]
        #     zimu = []
        #     zimu.append(num_zimu_string)
        if len(digits) ==0:
            return l

        if len(digits) == 1:
            num_zimu_string = self.hashMap[int(digits[0])]
            for i in range(len(num_zimu_string)):
                l.append(num_zimu_string[i])
            return l

        if len(digits) == 2:
            num_zimu_string1 = self.hashMap[int(digits[0])]
            num_zimu_string2 = self.hashMap[int(digits[1])]
            for i in range(len(num_zimu_string1)):
                for j in range(len(num_zimu_string2)):
                    ij = num_zimu_string1[i] + num_zimu_string2[j]
                    l.append(ij)
            return l

        if len(digits) == 3:
            num_zimu_string1 = self.hashMap[int(digits[0])]
            num_zimu_string2 = self.hashMap[int(digits[1])]
            num_zimu_string3 = self.hashMap[int(digits[2])]
            for i in range(len(num_zimu_string1)):
                for j in range(len(num_zimu_string2)):
                    for k in range(len(num_zimu_string3)):
                        ijk = num_zimu_string1[i] + num_zimu_string2[j] +num_zimu_string3[k]
                        l.append(ijk)
            return l

        if len(digits) == 4:
            num_zimu_string1 = self.hashMap[int(digits[0])]
            num_zimu_string2 = self.hashMap[int(digits[1])]
            num_zimu_string3 = self.hashMap[int(digits[2])]
            num_zimu_string4 = self.hashMap[int(digits[3])]
            for i in range(len(num_zimu_string1)):
                for j in range(len(num_zimu_string2)):
                    for k in range(len(num_zimu_string3)):
                        for v in range(len(num_zimu_string4)):
                            ijkv = num_zimu_string1[i] + num_zimu_string2[j] +num_zimu_string3[k]+num_zimu_string4[v]
                            l.append(ijkv)
            return l

 参考解析：回溯

当题目中出现 “所有组合” 等类似字眼时，我们第一感觉就要想到用回溯 

定义函数 backtrack(combination, nextdigit)，当 nextdigit 非空时，对于 nextdigit[0] 中的每一个字母 letter，执行回溯 backtrack(combination + letter,nextdigit[1:]，直至 nextdigit 为空。最后将 combination 加入到结果中。

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if not digits: return []

        """必须要用列表存储字符串"""
        phone = {'2':['a','b','c'],
                 '3':['d','e','f'],
                 '4':['g','h','i'],
                 '5':['j','k','l'],
                 '6':['m','n','o'],
                 '7':['p','q','r','s'],
                 '8':['t','u','v'],
                 '9':['w','x','y','z']}

                
        def backtrack(conbination,nextdigit):
            if len(nextdigit) == 0:
                res.append(conbination)
            else:
                for letter in phone[nextdigit[0]]:
                    backtrack(conbination + letter,nextdigit[1:])

        res = []
        backtrack('',digits)
        return res

 DFS解法：

首先存储每个数字对应的所有可能的字母，然后进行回溯操作。回溯过程中维护一个字符串，表示已有的字母排列，并记录当前回溯位置。每次尝试对应位置数字的所有字母，即可得到完整排列。

class Solution {
    vector<string> ans;
    string strs[10] = {
        "", "", "abc", "def",
        "ghi", "jkl", "mno",
        "pqrs", "tuv", "wxyz"
    };
public:
    vector<string> letterCombinations(string digits) {
        if (digits.empty()) return ans;
        dfs(digits, 0, "");
        return ans;
    }

    void dfs(string &digits, int idx, string combine) {
        if (idx == digits.length()) {
            ans.push_back(combine);
            return;
        }
        string s = strs[digits[idx] - '0'];
        for (int i = 0; i < s.length(); i++) {
            combine.push_back(s[i]);
            dfs(digits, idx + 1, combine);
            combine.pop_back();
        }
    }
};