DFS-困难

1  124. 二叉树中的最大路径和 https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/

考点：

1、后续遍历，根据左右节点和当前节点的值，判断当前节点最大路径的值

2、一个需要注意点是，左右节点+当前节点作为步骤1之外一个单独的路径（红色字体部分代码）

# 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 set_val(self, value):
        if value > self.max_num:
            self.max_num = value

    def helper(self, root):
        if root == None:
            return None

        left_max = self.helper(root.left)
        right_max = self.helper(root.right)
        # 叶子节点
        if left_max == None and right_max == None:
            self.set_val(root.val)
            return root.val
        elif left_max == None:
            value = max(right_max + root.val, root.val)
            self.set_val(value)
            return value
        elif right_max == None:
            value = max(left_max + root.val, root.val)
            self.set_val(value)
            return value
        else:
            value = max(left_max + root.val, right_max + root.val, root.val)
            value2 = left_max + right_max + root.val
            if value > value2:
                self.set_val(value)
            else:
                self.set_val(value2)
            return value

    def maxPathSum(self, root: TreeNode) -> int:
        # 后序遍历， 则当前节点最大路径为 max(左右+当前节点, 左+当前节点，右+当前节点， 当前节点)
        self.max_num = root.val
        self.helper(root)
        return self.max_num

2 980. 不同路径 III https://leetcode-cn.com/problems/unique-paths-iii/

考点：

1、深度搜索，碰到非-1值迭代搜索路径； 结束条件为 碰到结束点，满足条件是走过了全路径，即走过路径长度等于全路径长度

class Solution:
    def helper(self, grid, cur, cur_path):
        print(cur, self.end)
        if cur == self.end:
            if len(cur_path) == self.path_len:
                
                self.result.append(cur_path)
            return
        
        tmp_i, tmp_j = cur
        for i,j in [(tmp_i+1, tmp_j), (tmp_i -1, tmp_j), (tmp_i, tmp_j +1), (tmp_i, tmp_j -1)]:
            if 0 <= i < self.row and 0 <= j < self.col and not grid[i][j] == -1 and (i, j) not in cur_path:
                tmp_cur_path = list(cur_path)
                tmp_cur_path.append((i, j))
                self.helper(grid, (i, j), tmp_cur_path)


    def uniquePathsIII(self, grid: List[List[int]]) -> int:
        self.row = len(grid)
        self.col = len(grid[0])
        start = None
        self.end = None
        blocked = 0
        for i in range(self.row):
            for j in range(self.col):
                if grid[i][j] == 1:
                    start = (i, j)
                elif grid[i][j] == -1:
                    blocked += 1
                elif grid[i][j] == 2:
                    self.end = (i, j)
        
        self.path_len = self.row * self.col - blocked
        # DFS
        self.result = []
        self.helper(grid, start, [start])
        return len(self.result)

3.  839. 相似字符串组 https://leetcode-cn.com/problems/similar-string-groups/

考点： 深度搜索

class Solution:
    def fulfil(self, str1, str_list):
        str_len = len(str1)
        for str2 in str_list:
            diff = 0
            for i in range(str_len):
                if not str1[i] == str2[i]:
                    diff += 1
            if diff == 2 or diff == 0:
                return True
        return False

    def helper(self, A):
        if len(A) == 0:
            return

        found = False
        tmp_A = list(A)
        for s_str in A:
            for result in self.results:
                if self.fulfil(s_str, result):
                    found = True
                    result.append(s_str)
                    tmp_A.remove(s_str)
        
        if not found:
            tmp_str = A[0]
            self.results.append([tmp_str])
            tmp_A.remove(tmp_str)
        self.helper(tmp_A)
                    

    def numSimilarGroups(self, A: List[str]) -> int:
        self.results = []
        self.helper(A)
        return len(self.results)

　考虑优化,设置2级结果，已经遍历完全的组不参与遍历，继续超时

class Solution:
    def fulfil(self, str1, str_list):
        str_len = len(str1)
        for str2 in str_list:
            diff = 0
            for i in range(str_len):
                if not str1[i] == str2[i]:
                    diff += 1
            if diff == 2 or diff == 0:
                return True
        return False

    def helper(self, A):
        if len(A) == 0:
            self.results.append(self.results_tmp)
            self.results_tmp = []
            return

        found = False
        tmp_A = list(A)
        for s_str in A:
            if self.fulfil(s_str, self.results_tmp):
                found = True
                self.results_tmp.append(s_str)
                tmp_A.remove(s_str)
        
        if not found:
            tmp_str = A[0]
            if self.results_tmp:
                self.results.append(self.results_tmp)
                self.results_tmp = []
            tmp_A.remove(tmp_str)
            self.results_tmp.append(tmp_str)
            
        self.helper(tmp_A)
                    

    def numSimilarGroups(self, A: List[str]) -> int:
        self.results = []
        self.results_tmp = []
        self.helper(A)
        return len(self.results)

　想来想去，该种方法都需要 n *n 循环

    j继续优化，把字符窜分成一个个小类计算，还是时间超时，只能跑31 / 63 个通过测试用例

class Solution:  
    def fulfil(self, str1, str_list):
        str_len = len(str1)
        for str2 in str_list:
            diff = 0
            for i in range(str_len):
                if not str1[i] == str2[i]:
                    diff += 1
            if diff == 2 or diff == 0:
                return True
        return False

    def helper(self, A):
        if len(A) == 0:
            return 
 
        # 获取字符窜
        tmp_str = A[0]
        ori_list = [tmp_str]
        # 获取相似字符窜，删除
        A.remove(tmp_str)
        while ori_list:
            found = False
            tmp_list = []
            tmp_A = list(A)
            for a in tmp_A:
                if self.fulfil(a, ori_list):
                    found = True
                    tmp_list.append(a)
                    A.remove(a)
            ori_list = list(tmp_list)
            if not found:
                break
            
        # print(A)
        self.results += 1
        # 迭代
        self.helper(A)

    def numSimilarGroups(self, A: List[str]) -> int:
        # 时间超时，性能优化问题，首先想到是dict, 所以问题就变成使用什么样的key
        self.results = 0
        A_dict = collections.defaultdict(set)
        for a in A:
            A_dict["".join(sorted(a))].add(a)

        # print(A_dict)
        for value in A_dict.values():
            self.helper(list(value))
        # self.helper(A)
        return self.results

　

继续使用并查集优化，多通过一个用例，忧伤（32 / 63 个通过测试用例） 

class Solution:  
    def search(self, a, ilist):
        if ilist[a] != a:
            ilist[a] = self.search(ilist[a], ilist)
        return ilist[a]

    def union(self, a, b, ilist):
        aa = self.search(a, ilist)
        bb = self.search(b, ilist)
        # print("********")
        # print(a, aa)
        # print(b, bb)
        # print("%%%%%%%%%")
        if aa > bb:
            ilist[aa] = bb
        else:
            ilist[bb] = aa
        # print("****", ilist)


    def match(self, a, b):
        diff_len = 0
        for i in range(len(a)):
            if not a[i] == b[i]:
                diff_len += 1
        if diff_len == 2:
            return True
        return False

    def helper(self, str_list):
        if len(str_list) == 0:
            return 
 
        len_A = len(str_list)
        ilist = []
        ilist_dict = dict()
        for i in range(len_A):
            ilist.append(i)
            ilist_dict[str_list[i]] = i

        # print(ilist)
        # print(ilist_dict)
        for i in range(len_A-1):
            for j in range(i+1, len_A):
                if self.match(str_list[i], str_list[j]):
                    # print("&", ilist)
                    # print(i, j)
                    self.union(i ,j, ilist)
                    # print(ilist)
        
        for i in range(len(ilist)):
            self.search(i, ilist)
        self.results += len(set(ilist))



    def numSimilarGroups(self, A: List[str]) -> int:
        # 时间超时，性能优化问题，首先想到是dict, 所以问题就变成使用什么样的key
        self.results = 0
        A_dict = collections.defaultdict(set)
        for a in A:
            A_dict["".join(sorted(a))].add(a)

        # print(A_dict)
        for value in A_dict.values():
            self.helper(list(value))
        # self.helper(A)
        return self.results

4 514. 自由之路  https://leetcode-cn.com/problems/freedom-trail/

考点：

1、使用常规的 顺时针，逆时针的深度搜索，会超时

class Solution:
    def findRotateSteps(self, ring: str, key: str) -> int:
        # 1至100之间，值不大，尝试使用深度搜索
        ring_len = len(ring)
        key_len = len(key)
        result = set()
        result.add(float('inf'))
        def helper(ikey, cur_pos, cur_step):
            if not ikey:
                result.add(cur_step)
                return
            if cur_step > min(result):
                return
            
            if ring[cur_pos] == ikey[0]:
                helper(ikey[1:], cur_pos, cur_step)
                return
            
            # 顺时针
            for i in range(1, ring_len):
                if ikey[0] == ring[(cur_pos + i) % ring_len]:
                    helper(ikey[1:], (cur_pos + i) % ring_len, cur_step + i)
                    break
            # 逆时针
            for i in range(1, ring_len):
                if ikey[0] == ring[cur_pos - i]:
                    helper(ikey[1:], (cur_pos - i + ring_len) % ring_len, cur_step + i)
                    break




        helper(key, 0, 0)
        return min(result) + key_len

　　

 

1、首先是一个最大值、最小值问题，然后根据前一个值，得到后一个值的最优解，可以使用动态规划

class Solution:
    def findRotateSteps(self, ring: str, key: str) -> int:
        ring_len = len(ring)
        key_len = len(key)

        grid = [[float('inf')] * ring_len for _ in range(key_len)]

        # 各元素的位置
        pos = collections.defaultdict(list)
        for i in range(ring_len):
            pos[ring[i]].append(i)
        # print(pos)

        def min_distance(x, y):
            if x > y:
                x, y = y, x
            return min(y-x, ring_len-(y-x))
        # 设置初始位置
        for index in pos[key[0]]:
            grid[0][index] = min_distance(0, index)
        
        for i in range(1, len(key)):
            for j in pos[key[i]]:
                for k in pos[key[i-1]]:
                    # print(grid)
                    grid[i][j] = min(grid[i][j], min_distance(k, j) + grid[i-1][k])
        return min(grid[-1]) + len(key)