第148周周赛

 

第一题:递减元素使数组呈锯齿状

给你一个整数数组 nums，每次 操作 会从中选择一个元素并 将该元素的值减少 1。

如果符合下列情况之一，则数组 A 就是 锯齿数组：

• 每个偶数索引对应的元素都大于相邻的元素，即 A[0] > A[1] < A[2] > A[3] < A[4] > ...
• 或者，每个奇数索引对应的元素都大于相邻的元素，即 A[0] < A[1] > A[2] < A[3] > A[4] < ...

返回将数组 nums 转换为锯齿数组所需的最小操作次数

我的思路以为是DP，想了半天的状态转移方程未果，最后结束看了别人的代码，自己用python写的：

class Solution(object):
    def movesToMakeZigzag(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) < 3:
            return 0
        s,t = 0,0
        a,b = 0,0
        l = len(nums)
        for i in range(0,l,2):
            j = 0
            if i:
                j = max(j,nums[i]-nums[i-1]+1)
            if i<l-1:
                j = max(j,nums[i]-nums[i+1]+1)
            s += j
        for i in range(1,l,2):
            j = 0
            if i:
                j = max(j,nums[i]-nums[i-1]+1)
            if i<l-1:
                j = max(j,nums[i]-nums[i+1]+1)
            t += j
        return min(s,t)

竞赛第二题：5148. 二叉树着色游戏

有两位极客玩家参与了一场「二叉树着色」的游戏。游戏中，给出二叉树的根节点 root，树上总共有 n 个节点，且 n 为奇数，其中每个节点上的值从 1 到 n 各不相同。

 

游戏从「一号」玩家开始（「一号」玩家为红色，「二号」玩家为蓝色），最开始时，

「一号」玩家从 [1, n] 中取一个值 x（1 <= x <= n）；

「二号」玩家也从 [1, n] 中取一个值 y（1 <= y <= n）且 y != x。

「一号」玩家给值为 x 的节点染上红色，而「二号」玩家给值为 y 的节点染上蓝色。

 

之后两位玩家轮流进行操作，每一回合，玩家选择一个他之前涂好颜色的节点，将所选节点一个 未着色 的邻节点（即左右子节点、或父节点）进行染色。

如果当前玩家无法找到这样的节点来染色时，他的回合就会被跳过。

若两个玩家都没有可以染色的节点时，游戏结束。着色节点最多的那位玩家获得胜利 ✌️。

 

现在，假设你是「二号」玩家，根据所给出的输入，假如存在一个 y 值可以确保你赢得这场游戏，则返回 true；若无法获胜，就请返回 false。

class Solution(object):
    def btreeGameWinningMove(self, root, n, x):
        #整体思路先找到当前与x值相等的树节点，之后看该结点的左侧，右侧，父节点这三部分是否有其中部分大于其余两部分结点数和，有则返回True，反之的返回False
        """
        :type root: TreeNode
        :type n: int
        :type x: int
        :rtype: bool
        """
        self.X = None
        def dfs(now):
            if now == None:
                return
            if now.val == x:
                self.X = now
                return 
            dfs(now.left)
            dfs(now.right)
        dfs(root)
        def count(root):
            if not root:
                return 0
            return 1 + count(root.left) + count(root.right)
        l = count(self.X.left)
        r = count(self.X.right)
        top = n-l-r-1
        if top > l+r+1 or l > top+r+1 or r>top+l+1:
            return True
        return False