Python 计算子阵列的数量，使子阵列中的每个元素至少显示两次

我遇到了一个问题，似乎不能想出一个有效的解决办法。问题如下：

给定数组A，计算连续连续子数组的数量，使子数组中的每个元素至少出现两次

例如：

A = [0,0,0]

答案应该是3，因为我们有

A[0..1] = [0,0]
A[1..2] = [0,0]
A[0..3] = [0,0,0]

另一个例子：

A=[1,2,1,2,3]

答案应该是1，因为我们有：

A[0..3] = [1,2,1,2]

我似乎无法为这个算法找到一个有效的解决方案。我有一个算法可以检查每个可能的子数组（O（n^2）），但我需要更好的。这是我天真的解决方案：

def duplicatesOnSegment(arr):
    total = 0
    for i in range(0,len(arr)):
        unique = 0
        test = {}
        for j in range(i,len(arr)):
            k = arr[j]
            if k not in test:
                test[k] = 1
            else:
                test[k] +=  1

            if test[k] == 1:
                unique += 1
            elif test[k] == 2:
                unique -= 1
            if unique == 0:
                total += 1
    return total

---

首先，我会考虑对物权性质的否定：

not（all（l中的x至少出现两次））=存在（l中的x使得l中的任何其他y！=x）

我还不确定之前对你的问题的重新表述是否会有所帮助，但我作为数学家的直觉告诉我要这样做。。。尽管如此，仍然感觉像O（n^2）

my_list=['b'，'b'，'a'，'d'，'d'，'c']
def剩余_列表（el，列表）：
在列表中断言el
如果el==列表[-1]：返回[]
其他：返回列表[列表索引（el）+1:]
def有两个副本（el，列表）：
在列表中断言el
返回剩余列表中的el（el，列表）
列表（过滤器（lambda e:not（有重复的（e，我的列表）），我的列表））

当您在嵌套循环中使用

时，如果k不在测试中，您的程序在最坏情况下大于O（n^2）。最坏情况下的
中的
为O（n），导致总体最坏情况为O（n^3）。我有一个最坏的解决方案，O（n^2），它使用
collections.defaultdict
作为散列，以加快速度

从集合导入defaultdict
def func（A）：
结果=0
对于范围（0，len（A））中的i：
计数器=0
hash=defaultdict（int）
对于范围（i，len（A））内的j：
散列[A[j]+=1
如果散列[A[j]==2：
计数器+=1
如果计数器！=0和计数器==len（散列）：
结果+=1
返回结果