代码随想录算法训练营第22天｜77. 组合、216. 组合总和 III、17. 电话号码的字母组合

回溯三部曲：返回值和参数、终止条件、单层递归内的操作。回溯就是在递归的基础上对一些操作进行逆操作（撤销做过的操作）。
回溯是暴力的解法，本质上是要去遍历所有可能的结果，然后找到满足要求的那一种。

77. 组合

leetcode 77. 组合
代码随想录

class Solution:
    def backtracking(self, n, k, start_index, path, result):
        if len(path) == k:
            result.append(path[:])
            return
        # for i in range(start_index, n+1):
        for i in range(start_index, n+1 - (k - len(path)) + 1):  # 可以保证一共k个元素
            path.append(i)
            self.backtracking(n, k, i+1, path, result)
            path.pop()
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []
        self.backtracking(n, k, 1,[],result)
        return result

216. 组合总和 III

leetcode 216. 组合总和 III
代码随想录

class Solution:
    def backtracking(self, target, n, k, cur_sum, start_index, path, result):
        if cur_sum > target:
            return
        if len(path) == k: # 长度到了就该返回
            if cur_sum == target: # 符合条件就加入结果，不符合就直接返回了
                result.append(path[:])
            return
        for i in range(start_index, n+1- (k - len(path)) + 1):
            path.append(i)
            cur_sum += i
            self.backtracking(target,n,k,cur_sum, i+1, path,result)
            cur_sum -= i
            path.pop()
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        result = []
        self.backtracking(n,9,k,0,1,[],result)
        return result

17. 电话号码的字母组合

leetcode 17. 电话号码的字母组合
代码随想录

class Solution:
    def __init__(self):
        self.letter_map = [
            "",
            "",
            "abc",
            "def",
            "ghi",
            "jkl",
            "mno",
            "pqrs",
            "tuv",
            "wxyz"
        ]
        self.result = []
        self.s = ""
    def backtracking(self, digits, index):
        if index == len(digits):
            self.result.append(self.s)
            return
        digit = int(digits[index])
        letters = self.letter_map[digit]
        for letter in letters:
            self.s += letter
            self.backtracking(digits, index + 1)
            self.s = self.s[:-1]
    def letterCombinations(self, digits: str) -> List[str]:
        if len(digits) == 0:
            return []
        self.backtracking(digits, 0)
        return self.result