以相同元素开始和结束的子数组计数

在解决数组相关问题时，我们经常会遇到需要计算子数组数量的情况。其中，有一类问题是要求以相同元素开始和结束的子数组数量，本文将介绍两种不同的算法解决这类问题。

算法一：前缀和

这种算法是基于前缀和和哈希表实现的。首先，我们可以将数组中相同的元素都归为一类，用哈希表记录每个元素在数组中的起始位置和终止位置。然后，依次计算以每个元素作为起点的子数组数量，这个数量可以由该元素在哈希表中的记录计算得到。最后，我们将所有元素的子数组数量总和即为题目所求。

具体实现如下：

def countSubArrays(arr):
    n = len(arr)
    # 记录各元素的起始位置和终止位置
    hm = {}
    for i in range(n):
        if arr[i] not in hm:
            hm[arr[i]] = [i, i]
        else:
            hm[arr[i]][1] = i

    # 计算以每个元素为起点的子数组数量
    prefix_sum = [0] * n
    cnt = 0
    for i in range(n):
        if i > 0:
            prefix_sum[i] = prefix_sum[i-1]
        if hm[arr[i]][0] != i:
            continue
        j = hm[arr[i]][1]
        prefix_sum[j] += 1
        cnt += prefix_sum[j]
    return cnt

该算法的时间复杂度为 $O(n)$，其中 $n$ 表示数组长度。

算法二：快慢指针

这种算法是基于快慢指针实现的。我们通过维护两个指针 fast 和 slow，来实现对以相同元素开始和结束的子数组的计数。

初始化时，将 fast 和 slow 都指向数组的第一个元素。然后，fast 逐个向后遍历数组元素，如果当前元素等于数组首个元素，就令 slow 指向该元素。在遍历的过程中，对于每一对指向相同元素的 fast 和 slow，我们可以计算对应的子数组数量。最后，将所有子数组数量累加，即为题目所求。

具体实现如下：

def countSubArrays(arr):
    n = len(arr)
    cnt = 0
    slow, fast = 0, 0
    while slow < n and fast < n:
        while fast < n and arr[fast] != arr[0]:
            fast += 1
        if fast == n:
            break
        slow = fast
        while slow < n and arr[slow] == arr[0]:
            slow += 1
        cnt += (slow-fast+1) * (n-slow)
        fast = slow

    return cnt

该算法的时间复杂度为 $O(n)$，其中 $n$ 表示数组长度。需要注意的是，在最坏情况下，即数组中所有元素都相同时，该算法的时间复杂度将变为 $O(n^2)$。

总结

以上就是两种实现计算以相同元素开始和结束的子数组数量的算法。两种算法的实现都比较简单，读者可以根据具体情况选择使用哪种算法。值得注意的是，在使用快慢指针算法时，如果数组中存在大量相同的元素，该算法的时间复杂度将会退化至 $O(n^2)$，此时应该选择前缀和算法。