Week5-LeetCode

2810.故障键盘

关键思路：
将字符串反转等价于不对字符串进行反转，并在开头添加字符
故使用双端队列和一个bool变量head

class Solution(object):
    def finalString(self, s):
        """
        :type s: str
        :rtype: str
        """

        # 注意 python中不能改字符串内字符

        q = deque()
        head = False
        for ch in s:
            if ch != 'i':
                if head:
                    q.appendleft(ch)
                else:
                    q.append(ch)
            else:
                head = not head
        ans = ''.join(q)
        if head:
            ans = ans[::-1]
        return ans

其中head默认为假，如果head为真，反序输出，如果head为假，正序输出

1026. 节点与其祖先之间的最大差值 （中等）

关键思路：
对于每个节点，求其与祖先节点的最大差值，我们只需要求出该节点与祖先节点最大值和最小值的差值，取所有差值的最大值即可。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxAncestorDiff(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        global ans
        def dfs(root, mi, mx):
            global ans
            if root is None:
                return
            ans = max(ans, abs(mi - root.val), abs(mx - root.val))
            mi = min(mi, root.val)
            mx = max(mx, root.val)
            dfs(root.left, mi, mx)
            dfs(root.right, mi, mx)

        ans = 0
        dfs(root, root.val, root.val)
        return ans

2465. 不同的平均值数目 (简单)

关键思路：
不同平均值的数目其实可以看做不同和的数目

class Solution(object):
    def distinctAverages(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        seen = set() # 在集合中重复值会被自动忽略
        i, j = 0, len(nums) - 1
        while i < j:
            seen.add(nums[i] + nums[j])
            i += 1
            j -= 1
        return len(seen)

894. 所有可能的真二叉树 （中等）

关键思路：
动态规划→自底向上

• 节点数目序列分别为[(1, 1)] 的子树可以构造出节点数目 3 的子树
• 节点数目序列分别为[(1,3), (3, 1)] 的子树可以构造出节点数目 5 的子树
• 节点数目序列分别为[(1,5), (3, 3), (5, 1)] 的子树可以构造出节点数目 7 的子树
• 节点数目序列分别为[(1,i - 2), (3, i-4) ,..., (i - 2, 1)] 的子树可以构造出节点数目 i 的子树

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def allPossibleFBT(self, n):
        """
        :type n: int
        :rtype: List[TreeNode]
        """
        if n % 2 == 0:
            return []
        dp = [[] for _ in range(n + 1)]
        dp[1] = [TreeNode(0)]
        for i in range(3, n + 1, 2):
            for j in range(1, i, 2):
                for leftSubtree in dp[j]:
                    for rightSubtree in dp[i - 1 - j]:
                        root = TreeNode(0, leftSubtree, rightSubtree)
                        dp[i].append(root)

        return dp[n]