LeetCode笔记：Biweekly Contest 97

Posted 2023-02-19 Espresso Macchiato

• LeetCode笔记：Biweekly Contest 97
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

• 比赛链接：https://leetcode.com/contest/biweekly-contest-97

1. 题目一

给出题目一的试题链接如下：

• 2553. Separate the Digits in an Array

1. 解题思路

这一题只要按照题目翻译一下就行了，实现一个提取digit的函数，然后执行一下就行了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def separateDigits(self, nums: List[int]) -> List[int]:
        def num2digits(num):
            return [int(x) for x in str(num)]
        
        res = []
        for num in nums:
            res.extend(num2digits(num))
        return res

提交代码评测得到：耗时72ms，占用内存14.2MB。

2. 题目二

给出题目二的试题链接如下：

• 2554. Maximum Number of Integers to Choose From a Range I

1. 解题思路

这一题我的思路比较暴力，就是遍历一下所有没有被ban的数值，直至达到n或者超过上限即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxCount(self, banned: List[int], n: int, maxSum: int) -> int:
        banned = set(banned)
        res = 0
        cnt = 0
        for i in range(1, n+1):
            if i in banned:
                continue
            res += i
            if res > maxSum:
                return cnt
            cnt += 1
        return cnt

提交代码评测得到：耗时1142ms，占用内存16.1MB。

3. 题目三

给出题目三的试题链接如下：

• 2555. Maximize Win From Two Segments

1. 解题思路

这一题的思路的话就是找到两个不重合的区间，使得内部的prize个数最大。

因此，我们使用一个动态规划即可完成。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maximizeWin(self, prizePositions: List[int], k: int) -> int:
        n = len(prizePositions)
        unique_positions = sorted(set(prizePositions))
        m = len(unique_positions)
        
        @lru_cache(None)
        def fn(idx):
            return bisect.bisect_right(prizePositions, unique_positions[idx]+k) - bisect.bisect_left(prizePositions, unique_positions[idx])
        
        @lru_cache(None)
        def dp(idx):
            if idx >= m:
                return 0
            return max(fn(idx), dp(idx+1))
        
        res = max(fn(i) + dp(bisect.bisect_right(unique_positions, unique_positions[i]+k)) for i in range(m))

        return res

提交代码评测得到：耗时721ms，占用内存43.1MB。

4. 题目四

给出题目四的试题链接如下：

• 2556. Disconnect Path in a Binary Matrix by at Most One Flip

1. 解题思路

这一题我的一个大的思路就是找到grid上面每一个点上所有的需要经过该店的路线总数。

路过某一个上所有需要经过这个点的路线数目恰好等于总的路线数目，就说明每一条路线都必须要经过该点，那么删除该点就能够使得总的图不连通。

而要求得经过每一个点的路线总数，只要分别求得从起点到该点的路线数和从该点出发到终点的路线数，两者得乘积即是经过该点的总的路线数目。

2. 代码实现

给出python代码实现如下：

class Solution:
    def isPossibleToCutPath(self, grid: List[List[int]]) -> bool:
        n, m = len(grid), len(grid[0])
        
        def show(grid):
            for line in grid:
                print(line)
            print("=" * 5)
            return
        
        @lru_cache(None)
        def query_from(i, j):
            if i >= n or j >= m:
                return 0
            if grid[i][j] == 0:
                return 0
            if i == n-1 and j == m-1:
                return 1
            return query_from(i+1, j) + query_from(i, j+1)
        
        @lru_cache(None)
        def query_to(i, j):
            if i < 0 or j < 0:
                return 0
            if grid[i][j] == 0:
                return 0
            if i == 0 and j == 0:
                return 1
            return query_to(i-1, j) + query_to(i, j-1)

        from_paths = [[query_from(i, j) for j in range(m)] for i in range(n)]
        to_paths = [[query_to(i, j) for j in range(m)] for i in range(n)]
        tot_path = from_paths[0][0]

        return any(from_paths[i][j] * to_paths[i][j] == tot_path for i in range(n) for j in range(m) if (i, j) not in [(0,0), (n-1, m-1)])

提交代码评测得到：耗时1970ms，占用内存107.1MB。