leetcode 第十八天 2024.8.2

1. ：组合
 题目链接: 77. 组合 - 力扣（LeetCode）
应用条件：递归，回溯

难点：

这道题和寻找二叉树路径很像，只不过没有了现成的节点和数，但我们可以抽象出一个数出来帮助我们理顺递归和回溯的逻辑。这道题最关键的是要想到运用回溯来模拟无数次不定for循环的过程。下面先给出回溯的模板：
 

def backtrack(参数):
        if 终止条件:
            收割结果
            return 
        for 遍历本层种所有元素（节点）:
            处理节点
            self.backtrack()递归
            回溯，撤销处理结果

个人错误：

对于这道题，在回溯算法的参数中没有考虑到加入starinx来代表遍历开始的节点。

思路：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        curlist =[]
        res =[]
        starindx =1
        self.backtrack(n,k,curlist,res,starindx)
        return res

    def backtrack(self,n,k,curlist,res,starindx):
        if len(curlist) == k:
            res.append(curlist[:])
            return 
        for i in range(starindx,n+1):
            curlist.append(i)
            self.backtrack(n,k,curlist,res,i+1)
            curlist.pop()

优化：在回溯算法中可以进行剪枝优化，具体优化细节为

for i in range(startIndex, n - (k - len(path)) + 2):

2. ：.组合总和III
 题目链接: 216. 组合总和 III - 力扣（LeetCode）
应用条件：递归，回溯

难点：

本题的如果用到剪枝，注意回溯的时候也要把cursumm - i， 

个人错误：

思路：

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        curlist =[]
        res =[]
        starindx =1
        cursumm=0
        self.backtrack(n,k,curlist,res,starindx,cursumm)
        return res
      
    def backtrack(self,n,k,curlist,res,starindx,cursumm):
        if cursumm > n:
            return
        if len(curlist) == k:
            if cursumm == n:
                res.append(curlist[:])
            return 
        for i in range(starindx,9 - (k - len(curlist)) + 2):
            cursumm += i
            curlist.append(i)
            self.backtrack(n,k,curlist,res,i+1,cursumm)
            cursumm -= i
            curlist.pop()

3. ：电话号码的字母组合
 题目链接: 17. 电话号码的字母组合 - 力扣（LeetCode）
应用条件：回溯，递归

难点：

本题最大的难点就是想到数字和字母用map映射后怎么在回溯方法中，处理映射细节。

个人错误：

思路：

class Solution:
    def __init__(self):
        self.letterMap = [
            "",     # 0
            "",     # 1
            "abc",  # 2
            "def",  # 3
            "ghi",  # 4
            "jkl",  # 5
            "mno",  # 6
            "pqrs", # 7
            "tuv",  # 8
            "wxyz"  # 9
        ]
        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.letterMap[digit]    # 获取对应的字符集
        for i in range(len(letters)):
            self.s += letters[i]    # 处理字符
            self.backtracking(digits, index + 1)    # 递归调用，注意索引加1，处理下一个数字
            self.s = self.s[:-1]    # 回溯，删除最后添加的字符
    
    def letterCombinations(self, digits):
        if len(digits) == 0:
            return self.result
        self.backtracking(digits, 0)
        return self.result

4. ：从中序与后序遍历序列构造二叉树
 题目链接: 106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
应用条件：递归

难点：

要知道两个顺序构造一个唯一的二叉树的思路，后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。画个图会好理解很多。还有需要注意的是，一定要先切割中序数组，再根据切割后中序数组的长度去切割后序数组。

个人错误：

思路：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if not postorder:
            return None
        rootval = postorder[-1]
        root = TreeNode(rootval)
        splitindex = inorder.index(rootval)
        print(splitindex)
        inleftpe = inorder[:splitindex]
        inrightpe = inorder[splitindex+1:]
        postleftpe = postorder[:len(inleftpe)]
        postrightpe = postorder[len(inleftpe):len(postorder)-1]
        root.left = self.buildTree(inleftpe,postleftpe)
        root.right = self.buildTree(inrightpe,postrightpe)
        return root

5. ：最大二叉树
 题目链接: 654. 最大二叉树 - 力扣（LeetCode）
应用条件：递归

难点：

和上一道题一样的思路，甚至略简单。

个人错误：

思路：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 0:
            return None
        rootval = max(nums)
        root = TreeNode(rootval)
        splitindex = nums.index(rootval)
        leftpe = nums[:splitindex]
        rightpe = nums[splitindex+1:]
        root.left = self.constructMaximumBinaryTree(leftpe)
        root.right = self.constructMaximumBinaryTree(rightpe)
        return root