Leetcode 130周 周赛 题目和答案

校招小白 非科班出身 刚开始刷题 求大佬指路

# 第一题 能否被5整除
# 给定由若干 0 和 1 组成的数组 A。我们定义 N_i：从 A[0] 到 A[i] 的第 i 个子数组被解释为一个二进制数（从最高有效位到最低有效位）。
# 返回布尔值列表 answer，只有当 N_i 可以被 5 整除时，答案 answer[i] 为 true，否则为 false。
# 例一
# 输入：[0,1,1]
# 输出：[true,false,false]
# 解释：
# 输入数字为 0, 01, 011；也就是十进制中的 0, 1, 3 。只有第一个数可以被 5 整除，因此 answer[0] 为真。
# 例二
# 输入：[0,1,1,1,1,1]
# 输出：[true,false,false,false,true,false]

class Solution(object):    # 大神解法
    def prefixesDivBy5(self, A):
        """
        :type A: List[int]
        :rtype: List[bool]
        """
        n = len(A)
        ans = [False] * n
        val = 0
        for i, num in enumerate(A):
            val = (val * 2 + num) % 5
            if val == 0:
                ans[i] = True
        return ans

    
class Solution(object):    # 我的解法
    def prefixesDivBy5(self, A):
        """
        :type A: List[int]
        :rtype: List[bool]
        """
        ans = []
        string = ''
        for i in range(len(A)):
            string += str(A[i])
            ans.append(int(string,2) % 5 == 0)
        return ans

# 第二题 负二进制
# 给出数字 N，返回由若干 "0" 和 "1"组成的字符串，该字符串为 N 的负二进制（base -2）表示。
# 除非字符串就是 "0"，否则返回的字符串中不能含有前导零。
# 示例一
# 输入：2
# 输出："110"
# 解释：(-2) ^ 2 + (-2) ^ 1 = 2
# 示例二
# 输入：3
# 输出："111"
# 解释：(-2) ^ 2 + (-2) ^ 1 + (-2) ^ 0 = 3

class Solution:    # 大神解法
    def baseNeg2(self, N: int) -> str:
        if N == 0:
            return "0"
        nums = []
        while N != 0:
            r = N % (-2)
            N //= (-2)
            if r < 0:
                r += 2
                N += 1
            nums.append(r)
        return ''.join(map(str, nums[::-1]))
    
# 我不会做 TAT ORZ 求指导

# 第三题 链表中的下一个更大节点
# 给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, ... 。
# 每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，
# 那么就有 j > i 且  node_j.val > node_i.val，而 j 是可能的选项中最小的那个。如果不存在这样的 j，那么下一个更大值为 0 。
# 返回整数答案数组 answer，其中 answer[i] = next_larger(node_{i+1}) 。
# 注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其头节点的值为 2，第二个节点值为 1，第三个节点值为 5 。
# 示例一
# 输入：[2,1,5]
# 输出：[5,5,0]
# 示例二
# 输入：[2,7,4,3,5]
# 输出：[7,0,5,5,0]

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:    # 大神解法
    def nextLargerNodes(self, head: ListNode) -> List[int]:
        ans = []
        stack = []
        i = 0
        vals = []
        while head:
            num = head.val
            vals.append(num)
            while stack and num > vals[stack[-1]]:
                ans[stack.pop()] = num
            stack.append(i)
            ans.append(0)
            i += 1
            head = head.next
        return ans

class Solution:    # 我的解法
    def nextLargerNodes(self, head: ListNode) -> List[int]:
        A = []
        while head:
            A.append(head.val)
            head = head.next
        ans = []
        for i in range(len(A)):
            if A[i] == max(A[i:len(A)]):
                ans.append(0)
            else:
                for j in range(i+1,len(A)):
                    if A[j] > A[i]:
                        ans.append(A[j])
                        break
                    else:
                        continue
        return ans
# 因为不是科班没有学过数据结构不熟悉链表 转成列表操作 超时 TAT

# 第四题 飞地的数量
# 给出一个二维数组 A，每个单元格为 0（代表海）或 1（代表陆地）。
# 移动是指在陆地上从一个地方走到另一个地方（朝四个方向之一）或离开网格的边界。
# 返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。
# 示例一
# 输入：[[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
# 输出：3
# 解释： 
# 有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。
# 示例二
# 输入：[[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
# 输出：0
# 解释：
# 所有 1 都在边界上或可以到达边界。

class Solution:    # 大神的解法
    def numEnclaves(self, A: List[List[int]]) -> int:
        def dfs(r, c):
            if 0 <= r < len(A) and 0 <= c < len(A[0]) and A[r][c] == 1:
                A[r][c] = 0
                for newr, newc in (r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1):
                    dfs(newr, newc)
        # for i, row in enumerate(A):
        #     for j, val in enumerate(row):
        #         if i == 0 or i == len(A) - 1 or j == 0 or j == len(A[0]) - 1:
        #             dfs(i, j)
        m, n = len(A), len(A[0])
        for j in range(n):
            dfs(0, j)
            dfs(m - 1, j)
        for i in range(m):
            dfs(i, 0)
            dfs(i, n - 1)
        return sum(val == 1 for row in A for val in row)
    
# 我不会 TAT