leetcode第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 转换为锯齿数组所需的最小操作次数。

解题思路
        很简单的一道题，要么改奇数索引项，要么改变偶数索引项，改变成其左右项中比较小的那一项。

代码如下

class Solution:
    #获取左右中比较小的那一项
    def getMin(self, nums, i):
        if i == 0:
            if i == len(nums) - 1:
                return 0
            else:
                return nums[i + 1]
        elif i == len(nums) - 1 :
            return nums[i - 1]
        return min(nums[i - 1], nums[i + 1])

    def movesToMakeZigzag(self, nums: List[int]) -> int:
        sum_even = 0
        sum_odd = 0
        for i in range(len(nums)):
            if i % 2 == 0:  
                sum_even += max(0, nums[i] - self.getMin(nums, i) + 1)
            else:
                sum_odd +=  max(0, nums[i] - self.getMin(nums, i) + 1)
        return min(sum_even, sum_odd)

第二题 二叉树着色游戏

题目大意

        给你一颗n个节点的二叉树，节点编号为1-n，两个玩家玩，各取一个节点，一号玩家取x，二号玩家取除了x以外的其它一个节点y，之后两位玩家轮流进行操作，每一回合，玩家选择一个他之前涂好颜色的节点，将所选节点一个 未着色 的邻节点（即左右子节点、或父节点）进行染色。

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

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

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

解题思路

       

        以样例中的图为例，若一号玩家取3，则最优的策略存在于——二号玩家可以取1这个点，或者6这个点，或者7这个点这三种选择。即在父节点截断或在左右儿子处截断，取这三种情况下最大的一个，若大于n/2即为胜利。

代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    #统计该节点下的节点数
    def count_sum(self, root: TreeNode):
        if root == None:
            return 0
        else:
            return 1 + self.count_sum(root.left) + self.count_sum(root.right)
            

    def btreeGameWinningMove(self, root: TreeNode, n: int, x: int) -> bool:
        travel_tree = [root]
        i = 0
        max_num = 0
        while i < len(travel_tree):
            #若节点为玩家一取的节点，则在左子树，右子树，或父节点以外的子树中取最优值
            if travel_tree[i].val == x:
                left_sum = self.count_sum(travel_tree[i].left)
                right_sum = self.count_sum(travel_tree[i].right)
                max_num = max(max(left_sum, right_sum), n - left_sum - right_sum - 1)
                break
            if travel_tree[i].left != None:
                travel_tree.append(travel_tree[i].left)
            if travel_tree[i].right != None:
                travel_tree.append(travel_tree[i].right)
            i += 1
        return max_num > (n - max_num)

第三题 快照数组

题目大意

        实现支持下列接口的「快照数组」- SnapshotArray：

• SnapshotArray(int length) - 初始化一个与指定长度相等的 类数组 的数据结构。初始时，每个元素都等于 0。
• void set(index, val) - 会将指定索引 index 处的元素设置为 val。
• int snap() - 获取该数组的快照，并返回快照的编号 snap_id（快照号是调用 snap() 的总次数减去 1）。
• int get(index, snap_id) - 根据指定的 snap_id 选择快照，并返回该快照指定索引 index 的值。

解题思路
        初始化的意思理解错了，挂了一次。。。

        这题的意思是如果调用了snap则将这时的快照数组保存下来，然后再做后续操作。

        如果每次调用snap就保存复制一份，占用的空间很大，所以我想到用字典来保存对应索引的值，若不在字典里，即为0。

        为了每次调用snap不进行复制，在用get查找的时候可以先查找snap_id中的字典是否有index的索引，若有则返回；若没有则在snap_id - 1，snap_id - 2, …中的字典中找，直至snap_id < 0 为止，若没找到则返回0。

代码如下

class SnapshotArray:
    def __init__(self, length: int):
        self.snap_num = 0 
        self.list_dict = []
        self.length = length
        self.list_dict.append({})

    def set(self, index: int, val: int) -> None:
        self.list_dict[self.snap_num][index] = val

    def snap(self) -> int:
        self.snap_num += 1
        self.list_dict.append({})

        return self.snap_num - 1

    def get(self, index: int, snap_id: int) -> int:
        #如果代码写得严谨一点，需要判snap_id和index是否超出范围了的
        while snap_id >= 0:
            if index in self.list_dict[snap_id]:
                return self.list_dict[snap_id][index]
            snap_id -= 1
        return 0

第四题 段式回文

题目大意 

        对于一般回文 "abcba" 是回文，而 "volvo" 不是，但如果我们把 "volvo" 分为 "vo"、"l"、"vo" 三段，则可以认为 “(vo)(l)(vo)” 是段式回文（分为 3 段）。

        给你一个字符串 text，在确保它满足段式回文的前提下，请你返回 段 的 最大数量 k。

解题思路
       为了防止超时，这题用c++写了。。对于一串字符串是否为段回文串，我们可以这样想，若字符串长度为奇数，则最中间的那个字符肯定只属于中间那一串，而不会属于两侧的某一串。于是，我们从中间开始

       假设字符串为babcabb

       设f为计算回文串最大段数的数组,f[i]表示从i 到 l - i - 1 的最大段数，i只从0 ~ (l + 1)/2 

       f初始为1111000

       第一步，babcabb，红色的b开始，用b和a比不相等，所以f[2]还是1；

       第二步，babcabb，a 和 b 比 不相等，f[1]仍未1；babcabb，ab和ab比相等，f[1] = max(f[1],f[3] + 2) = 3

       第三步,  babcabb，b 和 b 比相等，f[0] = max(f[0],f[1] + 2) = 5,

                     babcabb，ba 和 bb 比不相等，f[0] = max(f[0],f[2]) = 5,

                    babcabb，bab 和 abb 比不相等，f[0] = max(f[0],f[3]) = 5

       结束，最后返回f[0]即可

代码如下

class Solution {
public:
    int longestDecomposition(string text) {
        int str_l = text.size();
        int f[1001];
        //初始化f数组
        memset(f, 0, sizeof(f));
        for (int i = 0; i <= (str_l + 1) / 2 - 1; ++i)
            f[i] = 1;
        //i从中间开始
        for (int i = str_l / 2 - 1; i >= 0; --i)
        {
            //j表示长度
            for (int j = 1; j <= str_l / 2 - i; ++j)
            {
                //做个优化，如果f[i + j] + 2 <= f[i] 就不用做字符串判断了
                if (f[i + j] + 2 > f[i])
                {
                    //flag为true表示两个字符串相等
                    bool flag = true;
                    for (int k = 1; k <= j; ++k)
                        if (text[i + k - 1] != text[str_l - 1 - i - j + k])
                        {
                            flag = false;
                            break;
                        }
                    if (flag)
                    {
                        f[i] = f[i + j] + 2;
                    }
                }
            }
        }
        return f[0];
    }
};