[LeetCode周赛复盘] 第 326 场周赛20230702

一、本周周赛总结

• T1 dp。
• T2 两数之和+分解质因数模板。
• T3 有序列表+滑窗。
• T4 维护有序列表+暴力。
  

6909. 最长奇偶子数组

6909. 最长奇偶子数组

1. 题目描述

2. 思路分析

• 感觉暴力好麻烦，于是dp了。
• 令f[i]为以i为结尾的最长有效子段。
• 那么可以按照题目要求条件转移。
• 注意：如果nums[i]%2=0,f[i]至少是1。

3. 代码实现

class Solution:
    def longestAlternatingSubarray(self, nums: List[int], t: int) -> int:
        ans = 0 
        n = len(nums)
        f = [0]*n 
        if nums[0]%2==0 and nums[0] <= t:
            f[0] = 1
        for i in range(1,n):
            if nums[i] > t:continue
            v = nums[i]%2
            if v == 0:
                f[i] = 1
            if v!= nums[i-1]%2 and f[i-1]:
                f[i] = 1+f[i-1]
        return max(f)

6916. 和等于目标值的质数对

6916. 和等于目标值的质数对

1. 题目描述

2. 思路分析

贴模板。

• 一看就是两数之和，注意枚举到n//2即可。

3. 代码实现

class PrimeTable:
    def __init__(self, n: int) -> None:
        self.n = n
        self.primes = primes = []  # 所有n以内的质数
        self.min_div = min_div = [0] * (n + 1)  # md[i]代表i的最小(质)因子
        min_div[1] = 1

        # 欧拉筛O(n)，顺便求出min_div
        for i in range(2, n + 1):
            if not min_div[i]:
                primes.append(i)
                min_div[i] = i
            for p in primes:
                if i * p > n: break
                min_div[i * p] = p
                if i % p == 0:
                    break


    def is_prime(self, x: int):
        """检测是否是质数，最坏是O(sqrt(x)"""
        if x < 3: return x == 2
        if x <= self.n: return self.min_div[x] == x
        for i in range(2, int(x ** 0.5) + 1):
            if x % i == 0: return False
        return True

    def prime_factorization(self, x: int):
        """分解质因数，复杂度
        1. 若x>n则需要从2模拟到sqrt(x)，如果中间x降到n以下则走2；最坏情况，不含低于n的因数，则需要开方复杂度
        2. 否则x质因数的个数，那么最多就是O(lgx)"""
        n, min_div = self.n, self.min_div
        for p in range(2, int(x ** 0.5) + 1):
            if x <= n: break
            if x % p == 0:
                cnt = 0
                while x % p == 0: cnt += 1; x //= p
                yield p, cnt
        while 1 < x <= n:
            p, cnt = min_div[x], 0
            while x % p == 0: cnt += 1; x //= p
            yield p, cnt
        if x >= n and x > 1:
            yield x, 1

    def get_factors(self, x: int):
        """求x的所有因数，包括1和x"""
        factors = [1]
        for p, b in self.prime_factorization(x):
            n = len(factors)
            for j in range(1, b + 1):
                for d in factors[:n]:
                    factors.append(d * (p ** j))
        return factors

    def mr_is_prime(self, x):
        """
        Miller-Rabin 检测. 检测x是否是质数，置信度: 1 - (1/4)^k. 复杂度k*log^3
        但是longlong以内可以用k==3或7的代价，换取100%置信度
        https://zhuanlan.zhihu.com/p/349360074
        """
        if x < 3 or x % 2 == 0:
            return x == 2
        if x % 3 == 0:
            return x == 3

        u, t = x - 1, 0
        while not u & 1:
            u >>= 1
            t += 1
        ud = (2, 325, 9375, 28178, 450775, 9780504, 1795265022)  # long long 返回用这个7个数检测100%正确
        # ud = (2, 7, 61)  # int 返回用这3个数检测100%正确
        # for _ in range(k):
        #     a = random.randint(2, x - 2)
        for a in ud:
            v = pow(a, u, x)
            if v == 1 or v == x - 1 or v == 0:
                continue
            for j in range(1, t + 1):
                v = v * v % x
                if v == x - 1 and j != t:
                    v = 1
                    break
                if v == 1:
                    return False
            if v != 1:
                return False
        return True

pt = PrimeTable(10**6+1)
class Solution:
    def findPrimePairs(self, n: int) -> List[List[int]]:
        ans = []
        for x in pt.primes:
            if x > n//2:
                break 
            if pt.is_prime(n-x):
                ans.append([x,n-x])
        return ans                         

6911. 不间断子数组

6911. 不间断子数组

1. 题目描述

2. 思路分析

• 看起来就是变长滑窗。
• 枚举每个i作为右端点向左能找到的合法窗口，这个窗口内所有数字差应该<=2。
• 那么难点就在于如何维护这个窗口内的最大最小值，直接用有序集合即可。

3. 代码实现

from sortedcontainers import SortedList 
class Solution:
    def continuousSubarrays(self, nums: List[int]) -> int:
        n = len(nums)
        q = deque()
        s = SortedList()
        ans = 0
        for v in nums:
            q.append(v)
            s.add(v)
            while s[-1] - s[0]>2:
                s.remove(q.popleft())
            ans += len(q)
        return ans 

6894. 所有子数组中不平衡数字之和

6894. 所有子数组中不平衡数字之和

1. 题目描述

2. 思路分析

• 和昨晚的G差不多。[abc周赛复盘] AtCoder Beginner Contest 308 20230701
• 数据量1000，考虑暴力枚举每个区间。
• 固定左端点，右端点右移时，增加集合内的性质。
• 用有序列表维护集合即可，添加一个数时，会拆分原本相邻的数，减少一个差，增加两个差。

3. 代码实现

from sortedcontainers import SortedList 
class Solution:
    def sumImbalanceNumbers(self, nums: List[int]) -> int:
        n = len(nums)
        s = SortedList()
        ans = 0
        for i in range(n):
            s.clear()
            p = 0 
            for j in range(i,n):
                v = nums[j]
                t = s.bisect_left(v)
                if t and t < len(s):
                    x = s[t] - s[t-1]
                    if x> 1:
                        p -= 1
                if t:
                    x = v - s[t-1]
                    if x > 1:
                        p += 1
                if t < len(s):
                    x = s[t] - v
                    if x >1:
                        p += 1
                s.add(v)
                ans += p 
        return ans     

参考链接