使用分段筛的质数最长子数组

在很多算法问题中，需要求出给定数组中的最长子数组，并且该子数组需要满足一定的条件。其中，在保证最长的前提下，通常需要满足某种单调性，以方便使用双指针或滑动窗口等高效算法。

在这里，我们将介绍如何使用分段筛的方法，求出给定数组中，质数的最长连续子数组。分段筛是指使用多次筛选，将大的数组切成较小的子数组进行筛选，最后合并结果的方法。

算法思路

我们可以先对整个数组进行一次筛选，去除不是质数的元素。为了保证效率，我们使用埃氏筛算法，将其时间复杂度优化到$O(n\log\log n)$。

在剩下的元素中，质数是足够稀疏的，因此我们可以将数组切成若干个连续且质数密度相似的子数组，分成多段进行单独的筛选和合并。这样做是因为在一个质数密度较高的子数组中，最长的质数子数组恰好在此段内，因此我们可以减少不必要的运算量。

对于每个子数组，我们使用线性筛算法，求出在该子数组中，每个数最小的质因数。我们可以使用与埃氏筛相同的方法，将时间复杂度优化到$O(n)$。

最后，对于整个数组，我们依次计算每个位置开始的最长连续质数子数组，取其中的最大值即为答案。

代码实现

埃氏筛

def eratosthenes(n: int) -> List[int]:
    # flags[i]表示i是否为质数
    flags = [True] * (n + 1)
    primes = []

    for i in range(2, n + 1):
        if flags[i]:
            primes.append(i)
        for j in range(len(primes)):
            if i * primes[j] > n:
                break
            flags[i * primes[j]] = False
            if i % primes[j] == 0:
                break

    return primes

分段筛质数

class SegmentSieve:
    def __init__(self, n: int):
        self._m = int(n ** 0.5)  # 块长
        self._primes = eratosthenes(self._m)  # 所有质数
        self._blocks = [0] * (self._m + 1)  # 每个块内的最小质数
        for prime in self._primes:
            for i in range(max(prime, (self._m + prime - 1) // prime) * prime, self._m + 1, prime):
                if not self._blocks[i]:
                    self._blocks[i] = prime

    def get_min_factor(self, x: int) -> int:
        if x <= self._m:
            return self._blocks[x]
        for prime in self._primes:
            if prime * prime > x:
                break
            if x % prime == 0:
                return prime
        return x

    def get_max_prime_length(self, nums: List[int]) -> int:
        n = len(nums)
        cnt = [0] * (n + 1)

        # 每个块的起始和结束位置
        block_start = [0]
        block_end = []
        for i in range(self._m, n + 1, self._m):
            block_start.append(i)
            block_end.append(i - 1)
        block_end.append(n)

        ans = 0
        for i in range(len(block_start)):
            # 对于每个子数组首次做一次扫描，计算出在当前子数组中，每个数开始的最长连续质数子数组的长度cnt[i]
            for j in range(block_start[i], block_end[i] + 1):
                if nums[j] > 1:
                    f = self.get_min_factor(nums[j])
                    if f == nums[j]:
                        cnt[j - block_start[i] + 1] = cnt[j - block_start[i]] + 1
                    else:
                        cnt[j - block_start[i] + 1] = 0
                else:
                    cnt[j - block_start[i] + 1] = 0
            # 对cnt求前缀和，得到某个长度下子数组中最多包含的质数个数，进而确定下一步的分块策略
            for j in range(1, len(cnt)):
                cnt[j] += cnt[j - 1]

            # 在当前子数组中，用类似双指针的方式找到最长的符合条件的质数子数组
            l, r = 0, 0
            while r <= block_end[i] - block_start[i]:
                if cnt[r] - cnt[l] > r - l + 1:
                    l += 1
                else:
                    r += 1
                ans = max(ans, cnt[r] - cnt[l - 1])

        return ans

总结

使用分段筛的方法，可以将时间复杂度从$O(n^2)$降至$O(n\log\log n)$。当需要求一个大数组中，最长且符合单调性的子数组时，该方法具有一定的优势。但是，该方法的具体实现较为繁琐，需要注意筛选条件、分块策略以及如何在两个相邻块之间合并筛选结果等问题。因此，在应用该方法时，需要细心、仔细地进行实现和调试。