Leetcode题解 - DFS部分简单题目代码+思路（113、114、116、117、1020、494、576、688）

这次接触到记忆化DFS，不过还需要多加练习

---

113. 路径总和 II - (根到叶子结点相关信息记录)

"""
思路：
本题 = 根到叶子结点的路径记录 + 根到叶子结点的值记录
"""
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        res = []
        def DFS(root, s, tmp):
            if not root:
                return
            if not root.left and not root.right and s-root.val == 0:
                res.append(tmp+[root.val].copy())
            DFS(root.left, s - root.val, tmp + [root.val])
            DFS(root.right, s - root.val, tmp + [root.val])
        DFS(root, sum, [])
        return res

---

114. 二叉树展开为链表

"""
思路：
    树的前序遍历再重新建树
    需要主要的点是本题要求的是 !原地! 展开，所以建树的时候原始根结点不动。
"""
class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root:
            return
        res = []
        # 前序遍历
        def Preorder(root):
            if not root:
                return
            res.append(root.val)
            Preorder(root.left)
            Preorder(root.right)
        Preorder(root)
        res = res[1:]
        treeNode = [root]
        # 重新建树，左节点为空，右节点为其先序遍历的下一个。
        while len(res) != 0:
            tree = treeNode.pop(0)
            rightChild = TreeNode(res.pop(0))
            tree.right = rightChild
            # 不要忘了将左边置为空
            tree.left = None
            treeNode.append(rightChild)

---

116. 填充每个节点的下一个右侧节点指针 / 117. 填充每个节点的下一个右侧节点指针 II

（116和117同样的代码都可以通过。）

"""
树的层次遍历，每一个的next指向同层的下一个即可。
"""
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return
        Q = [(root, 0)]
        pre = []
        tmp = []
        res = []
        level = set()
        level.add(0)
        # 对树进行层次遍历
        while len(Q) != 0:
            node, deepth = Q.pop(0)
            if deepth not in level:
                res.append(tmp.copy())
                tmp.clear()
                level.add(deepth)
            tmp.append(node)
            if node.left:
                Q.append((node.left, deepth+1))
            if node.right:
                Q.append((node.right, deepth+1))
        res.append(tmp.copy())
        # 每一个的next都是同层的下一个
        for i in range(1, len(res)):
            for j in range(len(res[i])-1):
                res[i][j].next = res[i][j+1]
        return root

---

1020. 飞地的数量

"""
从边界的1开始出发(对可以到达的1进行染色)，最后剩下的1就是飞地
"""
class Solution:
    def numEnclaves(self, A) -> int:
        # print(A)
        vis = set()
        directx = [-1, 1, 0, 0]
        directy = [0, 0, -1, 1]

        def DFS(x, y):
            A[x][y] = 2
            for i in range(4):
                newx, newy = x + directx[i], y + directy[i]
                if -1 < newx < len(A) and -1 < newy < len(A[0]):
                    if (newx, newy) not in vis and A[newx][newy] == 1:
                        vis.add((newx, newy))
                        if DFS(newx, newy):
                            return True
            return False
        # 对第一行和最后一行的1
        for i in range(len(A[0])):
            if A[0][i] == 1 and (0, i) not in vis:
                DFS(0, i)
            if A[len(A) - 1][i] == 1 and (len(A) - 1, i) not in vis:
                DFS(len(A) - 1, i)
        # 对第一列和最后一列的1
        for i in range(len(A)):
            if A[i][0] == 1 and (i, 0) not in vis:
                DFS(i, 0)
            if A[i][len(A[0]) - 1] == 1 and (i, len(A[0]) - 1) not in vis:
                DFS(i, len(A[0]) - 1)
        res = 0
        for i in A:
            for j in i:
                if j == 1:
                    res += 1
        return res

---

lru_cache装饰器

from functools import lru_cache
@lru_cache(None)

使用时候需要注意什么是可以被记忆的？

eg：为函数传入相同的一对参数其总是会返回相同的结果

---

494. 目标和 - 记忆化DFS

"""
思路：
利用DFS求出所有组合题型 -> DFS超时了（DFS不好好剪枝真的很容易超时