计数具有不同值的连续元素的数组

在进行算法和数据结构问题时，我们经常会遇到需要计算给定数组中连续元素具有不同值的数量的问题。本文将介绍如何在不同场景下解决这类问题。

普通数组

对于普通数组，最直接的方法是使用双指针法。我们使用两个指针i和j，初始值均为0，向右移动j指针直到遇到重复元素，此时计算连续不同元素的数量并将i指针移到j指向的元素，重复该过程直至j指针到达数组尾部。代码如下：

def count_distinct(arr: List[int]) -> int:
    if not arr:
        return 0
    i, j = 0, 1
    count = 1
    while j < len(arr):
        if arr[j] != arr[j-1]:
            count += 1
        j += 1
        if j == len(arr) or arr[j] == arr[j-1]:
            i = j
    return count

该算法的时间复杂度为O(n)，空间复杂度为O(1)。

循环数组

对于循环数组，我们可以将其看做是普通数组的衍生形式。有两种情况需要考虑：

1. 循环数组头部和尾部的元素相等，例如[1,2,3,4,5,1]。
2. 循环数组头部和尾部的元素不相等，例如[1,2,3,4,5,6]。

对于情况1，我们可以将数组拆成两个普通数组[1,2,3,4,5]和[1]来处理，然后将它们的结果相加即可。代码如下：

def count_distinct(arr: List[int]) -> int:
    if not arr:
        return 0
    if arr[0] == arr[-1]:
        return count_distinct(arr[:-1]) + count_distinct(arr[-1:])
    i, j = 0, 1
    count = 1
    while j < len(arr):
        if arr[j] != arr[j-1]:
            count += 1
        j += 1
        if j == len(arr) or arr[j] == arr[j-1]:
            i = j
    return count

对于情况2，我们可以使用类似于双指针的方法，不同之处在于当j指针到达尾部时，需要从头开始遍历直到i指针的位置才能统计所有的元素。代码如下：

def count_distinct(arr: List[int]) -> int:
    if not arr:
        return 0
    i, j = 0, 1
    count = 1
    while j < len(arr):
        if arr[j] != arr[j-1]:
            count += 1
        j += 1
        if j == len(arr):
            j = 0
            while j < i:
                if arr[j] != arr[j-1]:
                    count += 1
                j += 1
            return count
        if arr[j] == arr[j-1]:
            i = j
    return count

连续子数组

对于连续子数组，我们可以使用滑动窗口的方法。我们使用两个指针left和right表示窗口的左右边界，初始值均为0，使用一个字典来记录每个元素的出现次数，当字典中某个元素的值大于1时，说明出现了重复元素，此时right指针右移一位并将该元素个数减一，直到字典中所有元素的值都为1，即没有重复元素，此时用长度更新最大长度。代码如下：

def count_distinct(arr: List[int]) -> int:
    if not arr:
        return 0
    left, right = 0, 0
    freq = defaultdict(int)
    max_len = 0
    while right < len(arr):
        freq[arr[right]] += 1
        while freq[arr[right]] > 1:
            freq[arr[left]] -= 1
            left += 1
        max_len = max(max_len, right - left + 1)
        right += 1
    return max_len

该算法的时间复杂度为O(n)，空间复杂度为O(n)。