力扣39.组合总和、22.括号生成、79.单词搜索

39.组合总和

思路：

和之前的题目类似，这里题目说明可以重复选取元素，所以用一个变量记录当前下标，递归从当前下标开始

代码：

python 复制代码

class Solution:
    def backtracking(self, curSum, candidates, path, result, index, target):
        if curSum > target:
            return
        
        if curSum == target:
            result.append(path[:])
            return

        for i in range(index, len(candidates)):
            curSum += candidates[i]
            path.append(candidates[i])
            self.backtracking(curSum, candidates, path, result, i, target)
            path.pop()
            curSum -= candidates[i]

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        result = []
        self.backtracking(0, candidates, [], result, 0, target)
        return result

22.括号生成

思路：

终止条件：路径长度等于给定长度的两倍
回溯：根据当前路径中左括号和右括号的数量来决定是否可以添加左括号或右括号，并进行递归。

代码：

python 复制代码

class Solution:
    def backtracking(self, n, path, result, left, right):
        if len(path) == n * 2:
            result.append(path[:])
            return

        if left < n:
            self.backtracking(n, path + "(", result, left + 1, right)

        if right < left:
            self.backtracking(n, path + ")", result, left, right + 1)

    def generateParenthesis(self, n: int) -> List[str]:
        result = []
        self.backtracking(n, "", result, 0, 0)
        return result

79.单词搜索

参考：

https://leetcode.cn/problems/word-search/solutions/2361646/79-dan-ci-sou-suo-hui-su-qing-xi-tu-jie-5yui2

思路：

终止条件：返回真------单词长度走完；返回假（剪枝）------越界/字符不相同
回溯：判断完终止条件之后，把当前矩阵字符置为空，以免重复访问；对四个方向进行递归操作，只要有一个方向返回真即可，只需进行或操作；递归完成后，当前矩阵字符置为原来的字符

代码：

python 复制代码

class Solution:
    # i, j用于指示矩阵的下标，k用于指示单词的下标
    def backtracking(self, board, word, i, j, k):
        # 当越界/字符不相等时，返回假
        if not 0 <= i < len(board) or not 0 <= j < len(board[0]) or board[i][j] != word[k]:
            return False
        # 单词走到最后了
        if k == len(word) - 1:
            return True

        board[i][j] = ''  # 当前先置空，以防重复访问
        # 只要有一个方向返回真即可
        result = self.backtracking(board, word, i + 1, j, k + 1) or self.backtracking(board, word, i - 1, j, k + 1) or self.backtracking(board, word, i, j + 1, k + 1) or self.backtracking(board, word, i, j - 1, k + 1)
        board[i][j] = word[k]  # 回溯，设回原来的值

        return result

    def exist(self, board: List[List[str]], word: str) -> bool:
        for i in range(len(board)):
            for j in range(len(board[0])):
                if self.backtracking(board, word, i, j, 0):
                    return True

        return False