LeetCode笔记：Biweekly Contest 55（补发）

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

1. 题目一

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

• 1909. Remove One Element to Make the Array Strictly Increasing

1. 解题思路

这一题我做的算是比较繁琐的，不过思路还是比较清晰的，因为横竖就两种可能性，一种是凹陷的情况，一种是凸出的情况，对这两种情况分别进行一下考察即可。

2. 代码实现

给出python代码如下：

class Solution:
    def canBeIncreasing(self, nums: List[int]) -> bool:
        def is_convex(nums):
            nums = [0] + nums
            pre = 0
            cnt = 0
            for idx, x in enumerate(nums):
                if idx == 0:
                    continue
                if x <= pre:
                    if x <= nums[idx-2]:
                        return False
                    else:
                        cnt +=1
                pre = x
            return cnt <= 1
        
        def is_concave(nums):
            pre = 0
            cnt = 0
            for idx, x in enumerate(nums):
                if x <= pre:
                    cnt += 1
                else:
                    pre = x
            return cnt <= 1
        
        return is_convex(nums) or is_concave(nums)

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

当前最优的代码实现耗时32ms，就是把上述两次判断合在了一起，有兴趣的读者可以自行去考察一下。

2. 题目二

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

• 1910. Remove All Occurrences of a Substring

1. 解题思路

这一题我的思路是使用栈，不断地将元素放入到栈当中，当最后一些元素刚好为part时就执行pop操作，然后遍历完所有的字符即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def removeOccurrences(self, s: str, part: str) -> str:
        n = len(part)
        ss = s[:n-1]
        for c in s[n-1:]:
            ss += c
            if ss[-n:] == part:
                ss = ss[:-n]
        return ss

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

当前最优的算法实现耗时16ms，其思路是通过python内置的find函数来优化字符串检索的效率。

3. 题目三

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

• 1911. Maximum Alternating Subsequence Sum

1. 解题思路

这一题的思路还是比较明确的，就是动态规划。

我们每次保存两个数据，分别表示从当前位开始奇数位减去偶数位的最大和最小值，则有递推关系：

• $f_i=min(f_{i+1},x_i-g_{i+1})$
• $g_i=max(g_{i+1},x_i-f_{i+1})$

其中，$g_i$和$f_i$分别表示从第i位开始时所有的组合当中奇数位减去偶数位数字的最大和最小值。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxAlternatingSum(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [[0, 0] for _ in range(n+1)]
        res = max(nums)
        for i in range(n-1, -1, -1):
            dp[i][0] = min(dp[i+1][0], nums[i] - dp[i+1][1])
            dp[i][1] = max(dp[i+1][1], nums[i] - dp[i+1][0])
            res = max(dp[i][1], res)
        return res

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

4. 题目四

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

• 1912. Design Movie Rental System

1. 解题思路

这道题其实按照题目意思直接构造就行了。

每部电影在被借出前需要按照价格以及商店进行排序，借出之后需要按照价格、商店以及电影进行排序。

因此，我们构造一个有序数列然后每次通过二分法进行数据的插入和删除即可。

2. 代码实现

给出python代码实现如下：

class MovieRentingSystem:

    def __init__(self, n: int, entries: List[List[int]]):
        self.movies = defaultdict(list)
        self.prices = defaultdict(dict)
        self.rented = []
        for shop, movie, price in entries:
            bisect.insort(self.movies[movie], (price, shop))
            self.prices[movie][shop] = price
        return

    def search(self, movie: int) -> List[int]:
        return [x[1] for x in self.movies[movie][:5]]

    def rent(self, shop: int, movie: int) -> None:
        price = self.prices[movie][shop]
        idx = bisect.bisect_left(self.movies[movie], (price, shop))
        self.movies[movie].pop(idx)
        bisect.insort(self.rented, (price, shop, movie))
        return

    def drop(self, shop: int, movie: int) -> None:
        price = self.prices[movie][shop]
        idx = bisect.bisect_left(self.rented, (price, shop, movie))
        self.rented.pop(idx)
        bisect.insort(self.movies[movie], (price, shop))
        return

    def report(self) -> List[List[int]]:
        return [[x[1], x[2]] for x in self.rented[:5]]

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