LeetCode 第 204 场周赛

5499. 重复至少 K 次且长度为 M 的模式

垃圾题解 略

垃圾代码

class Solution:
    def containsPattern(self, arr: List[int], m: int, k: int) -> bool:
        print('ohhh')
        n = len(arr)
        if m * k > n: return False
        for i in range(n - m + 1):
            a = arr[i : i + m]
            c = 1
            j = i + m
            while j <= n - m:
                kk = 0
                while kk < m and a[kk] == arr[j + kk]: kk += 1
                if kk == m: c += 1
                else: break
                j += kk
            # print(str(i) + " " + str(c) + "-----")
            if c >= k: return True
        return False

5500. 乘积为正数的最长子数组长度

垃圾题解 略

垃圾代码

class Solution:
    def getMaxLen(self, nums: List[int]) -> int:
        l0, l1, l_1 = -1, 0, -1
        flag = False
        res = 0
        for i in range(len(nums)):
            n = nums[i]
            if n == 0:
                l0 = i
                l1 = i + 1
                l_1 = -1
                flag = False
            else:
                if n < 0:
                    flag = not flag
                    if l_1 == -1: l_1 = i
                if flag and l_1 != -1: res = max(res, i - l_1)
                elif not flag: res = max(res, i - l1 + 1)
        #     print(res, end='  ')
        # print('----')
        return res

5501. 使陆地分离的最少天数

垃圾题解

求把一个连通分量拆成俩的最小切割次数. 这题撑死最多切两次 (即当图有三个及以上的点时, 图的边缘必存在只有两条边的点).

先遍历一遍全图, 如果本来就有不止一个分量, 直接返回 0.

然后判断一个特例: 连通分量就一个, 但该分量就两个点. 这样的话删除一个后依然是一个连通分量. 所以要删两次, 返回 2.

然后遍历所有点, 如果找到一个点只有一条边, 返回 1; 如果找到有点有两条边, 则临时删除该点, DFS 遍历全图判断是不是变成了两个分量, 是则返回 1 (不要问我什么割点、什么 Tarjan, 爷忘光啦. 反正我赌 LeetCode 会让我过).

剩下的情况直接返回 2.

垃圾代码

class Solution:
    def minDays(self, grid: List[List[int]]) -> int:
        n, m = len(grid), len(grid[0])
        cnt1 = 0
        vis = [[False] * m for _ in range(n)]
        def dfs(g, v, x, y):
            if v[x][y]: return True
            v[x][y] = True
            if x > 0 and g[x - 1][y] == 1 and not v[x - 1][y]: dfs(g, v, x - 1, y)
            if y > 0 and g[x][y - 1] == 1 and not v[x][y - 1]: dfs(g, v, x, y - 1)
            if x < len(g) - 1 and g[x + 1][y] == 1 and not v[x + 1][y]: dfs(g, v, x + 1, y)
            if y < len(g[0]) - 1 and g[x][y + 1] == 1 and not v[x][y + 1]: dfs(g, v, x, y + 1)
        flag = False
        for i in range(n):
            for j in range(m):
                if grid[i][j] == 1: cnt1 += 1
                if grid[i][j] == 1 and not vis[i][j]:
                    if flag: return 0
                    flag = True
                    dfs(grid, vis, i, j)
        if cnt1 == 2: return 2
        for i in range(n):
            for j in range(m):
                if grid[i][j] == 0: continue
                c = []
                if i > 0 and grid[i - 1][j] == 1: c.append((i - 1, j))
                if j > 0 and grid[i][j - 1] == 1: c.append((i, j - 1))
                if i < n - 1 and grid[i + 1][j] == 1: c.append((i + 1, j))
                if j < m - 1 and grid[i][j + 1] == 1: c.append((i, j + 1))
                if len(c) == 1: return 1
                if len(c) != 2: continue
                grid[i][j] = 0
                for ii in range(n):
                    for jj in range(m):
                        vis[ii][jj] = False
                dfs(grid, vis, c[0][0], c[0][1])
                if not vis[c[1][0]][c[1][1]]: return 1
                grid[i][j] = 1
        return 2

5502. 将子数组重新排序得到同一个二叉查找树的方案数

垃圾题解

给一棵二叉查找树, 问有多少种方法产生此树 (即求可行的输入顺序的个数 - 1).

根节点必为输入的第一个. 剩下的, 左右子树互不影响, 可以随意穿插 (只要左子树的顺序之间、右子树的顺序之间的顺序不变即可).

所以 输入顺序个数 = 左子树输入顺序个数 * 右子树输入顺序个数 * 左右子树所有穿插的可能数, 其中 左右子树所有穿插的可能数 = C(总结点数 - 1, 左或右子树节点个数).

垃圾代码

import math
class Solution:
    def numOfWays(self, nums: List[int]) -> int:
        def comb(n, m):
            return math.factorial(n)//(math.factorial(n-m)*math.factorial(m))
        MOD = int(10 ** 9 + 7)
        def dfs(arr):
            n = len(arr)
            if n <= 2: return 1
            left, right = [], []
            for i in range(1, n):
                if arr[i] < arr[0]: left.append(arr[i])
                else: right.append(arr[i])
            l, r = len(left), len(right)   
            return dfs(left) * dfs(right) * comb(n - 1, l) % MOD
        return dfs(nums) - 1