代码随想录算法训练营第二十五天丨216. 组合总和 III、17. 电话号码的字母组合

216. 组合总和 III

原版：

根据昨天所学，思路很好理解了，先定义数组path和res用于枚举和收集结果。定义回溯函数用于递归找深度，内置for循环找广度。

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        self.path = []
        self.res = []

        def backtracking(k, n, start):
            if sum(self.path) == n and len(self.path) == k:
                self.res.append(self.path[:])
                return
            
            for i in range(start, 10):
                self.path.append(i)
                backtracking(k, n, i+1)
                self.path.pop()

        backtracking(k, n, 1)
        return self.res

剪枝：

剪枝3处，

第一处是运行递归函数之前，如果比最小的小，或者比最大的大，直接return空集。

第二处是每次记录path的和，如果path的和已经比n大了，就没有必要再递归下去了。

第三处是控制循环上界，如果从上界开始，到末尾都凑不齐一个长度未k的数组，就没有必要再递归了。

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        self.path = []
        self.res = []
        if n < sum(range(1,k + 1)) or n > sum(range(10 - k, 10)):
            return []

        def backtracking(k, n, start, sumPath):
            if sumPath > n:
                return
            if sum(self.path) == n and len(self.path) == k:
                self.res.append(self.path[:])
                return
            for i in range(start, 11 - k + len(self.path)):
                sumPath += i
                self.path.append(i)
                backtracking(k, n, i+1, sumPath)
                sumPath -= i
                self.path.pop()

        backtracking(k, n, 1, 0)
        return self.res

17. 电话号码的字母组合

自己写的原版：

仍然是枚举，广度是每个digit对应的字母，深度是所有的digits。画树图真的有助于理解！

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        self.digits_dict = {'2':'abc','3':'def','4':'ghi', '5':'jkl','6':'mno','7':'pqrs','8':'tuv','9':'wxyz'}
        self.path = []
        self.res = []
        if not digits: return []

        def backtracking(digits, start):
            if len(self.path) == len(digits):
                self.res.append(self.path[:])
                return
            
            for char in self.digits_dict[digits[start]]:
                self.path.append(char)
                backtracking(digits,start + 1)
                self.path.pop()

        backtracking(digits, 0)
        return [''.join(_) for _ in self.res]

改良版(装*版

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

        phone_map = {
            "2": "abc",
            "3": "def",
            "4": "ghi",
            "5": "jkl",
            "6": "mno",
            "7": "pqrs",
            "8": "tuv",
            "9": "wxyz"
        }

        def backtrack(index: int, path: str):
            if len(path) == len(digits):
                combinations.append(path)
                return

            possible_letters = phone_map[digits[index]]
            for letter in possible_letters:
                backtrack(index + 1, path + letter)

        combinations = []
        backtrack(0, "")
        return combinations

今日总结：

比昨天好一些了，不剪枝的话自己也能够写出来。