LeetCode笔记：Weekly Contest 352

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

• 比赛链接：https://leetcode.com/contest/weekly-contest-352/

1. 题目一

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

• 2760. Longest Even Odd Subarray With Threshold

1. 解题思路

这一题思路就是一个贪婪算法，从左往右看每一个符合要求的子串的最大长度返回即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def longestAlternatingSubarray(self, nums: List[int], threshold: int) -> int:
        pre, cnt, res = 1, 0, 0
        for x in nums:
            if x > threshold:
                res = max(res, cnt)
                pre, cnt = 1, 0
            elif x % 2 == (pre + 1) % 2:
                cnt += 1
                pre = x % 2
            elif x % 2 == 0:
                res = max(res, cnt)
                cnt = 1
                pre = 0
            else:
                res = max(res, cnt)
                pre, cnt = 1, 0
        res = max(res, cnt)
        return res

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

2. 题目二

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

• 2761. Prime Pairs With Target Sum

1. 解题思路

这一题思路并不复杂，就是先找到所有的质数，然后依次看一下每一个质数是否可以找到另一个对应的质数使得两者相加恰好等于目标数字。

唯一的难点在于质数的求解复杂度较高，不过所幸这个东西只需要计算一次，因此我们是先将其计算存储下来即可。

2. 代码实现

给出python代码实现如下：

@lru_cache(None)
def get_primes():
    n = 10**6
    status = [0 for _ in range(n)]
    primes = []
    for i in range(2, n):
        if status[i] == 1:
            continue
        primes.append(i)
        for j in range(i, n, i):
            status[j] = 1
    return primes

class Solution:
    def findPrimePairs(self, n: int) -> List[List[int]]:
        primes = get_primes()
        prime_set = set(primes)
        res = []
        for x in primes:
            if x > n / 2:
                break
            if n-x in prime_set:
                res.append([x, n-x])
        return res

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

3. 题目三

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

• 2762. Continuous Subarrays

1. 解题思路

这一题我的思路是维护一个有序的滑动窗口，考察每一个位置$i$作为左起点时右侧的最大可能位置$j$，然后$j-i+1$就是以$i$为起点可以组成的所有的连续子串的数目。

显然$i,j$的移动都是单向的，且不会有重复，因此我们直接进行相加即可，整体的时间复杂度就是$O(NlogN)$。

2. 代码实现

给出python代码实现如下：

class Solution:
    def continuousSubarrays(self, nums: List[int]) -> int:
        s = []
        i, j, n = 0, 0, len(nums)
        res = 0
        while j < n:
            bisect.insort(s, nums[j])
            j += 1
            while s[-1] - s[0] > 2:
                s.pop(bisect.bisect_left(s, nums[i]))
                i += 1
            res += j-i
        return res

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

4. 题目四

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

• 2763. Sum of Imbalance Numbers of All Subarrays

1. 解题思路

这一题我的思路多少有点暴力，就是考察每一个位置作为左起点时，所有的subarray当中的imbalance数的个数。

但是，如果对任意的$i,j$都进行计算那么时间复杂度一定过高，不过，如果我们动态地考察每新加一个数之后imbalance数的变化，就能够快速地在$O(logN)$的时间复杂度内快速确定每一段子串当中的imbalance数的个数。

此时，总体的时间复杂度就是$O(N^{2}log(N))$。

2. 代码实现

给出python代码实现如下：

class Solution:
    def sumImbalanceNumbers(self, nums: List[int]) -> int:
        n = len(nums)
        
        res = 0
        for i in range(n-1):
            s = [nums[i]]
            cnt = 0
            for j in range(i+1, n):
                idx = bisect.bisect_left(s, nums[j])
                if idx == 0:
                    if s[0] - nums[j] > 1:
                        cnt += 1
                elif idx == j-i:
                    if nums[j] - s[-1] > 1:
                        cnt += 1
                else:
                    if s[idx] - s[idx-1] > 1:
                        cnt -= 1
                    if s[idx] - nums[j] > 1:
                        cnt += 1
                    if nums[j] - s[idx-1] > 1:
                        cnt += 1
                res += cnt
                s.insert(idx, nums[j])
        return res

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