给定数组具有二元等效项的子序列数

当我们对一个数组进行子序列计算时，有时候需要判断子序列中是否存在二元等效项。二元等效项指的是数组中两个元素 i 和 j，它们满足 i < j 且具有相同的值。在这种情况下，我们将规定这两个元素为一个二元等效项。

问题描述：给定一个整数数组 nums，计算具有二元等效项的非空连续子序列数。

例如：

输入：[1, 2, 3, 1, 1, 2] 输出：9 解释：具有二元等效项的子序列分别为：[1], [1], [2], [1, 2], [2], [1, 2], [1, 1], [2], [1, 2]

方法一：暴力解法

首先考虑暴力解法，枚举所有的子序列，若该子序列存在二元等效项，则计数器加一。具体实现可参考以下代码：

def num_equiv_subarr(nums):
    n = len(nums)
    res = 0
    for i in range(n):
        for j in range(i+1, n+1):
            s = set(nums[i:j])
            if len(s) != j-i:
                res += 1
    return res

该算法时间复杂度为 O(n^3)，明显效率很低。

方法二：前缀和 + 哈希表

接下来考虑优化算法。从方法一中，我们可以看到子序列的判断复杂度是 O(n)，因此考虑优化这个过程。

我们可以发现，若一个子序列中存在二元等效项，则该子序列中最近的两个相同元素之间的元素都是冗余的。例如，对于数组 [1, 2, 3, 1, 1, 2]，子序列 [1, 2, 3, 1, 1, 2] 就是不合法的，因为其中的 [1, 1] 和 [1, 1, 2] 都是冗余的。

因此，我们可以使用哈希表记录某个元素最近一次出现的位置，从而判断序列中是否存在二元等效项。

具体实现上，我们可以采用类似前缀和的思路。首先，初始化哈希表 h，将 h[nums[0]] 设为 0。然后，逐个遍历数组 nums，对于下标 i，我们需要找到满足以下条件的最小下标 j：

1. j >= h[nums[i]] + 1
2. nums[h[nums[i]] + 1:i] 中不存在 nums[i]

这个过程可以使用一个指针 left 来记录，left 从右向左遍历 nums[h[nums[i]]+1:i]。一旦 left 指向的元素等于 nums[i]，则令 j = left，跳出循环。

对于左端点 i，记 count[i] 表示以 i 为左端点的合法子序列中，右端点最远可以到达哪里。由于我们需要求的是非空连续子序列的个数，因此答案为所有 count[i] 的和。

具体实现可参考以下代码：

def num_equiv_subarr(nums):
    n = len(nums)
    h = {nums[0]: 0}
    res = 0
    left = 0
    count = [0] * n
    count[0] = 1
    for i in range(1, n):
        if nums[i] not in h:
            h[nums[i]] = i
        else:
            j = h[nums[i]]
            while left < j:
                if nums[left] == nums[i]:
                    break
                left += 1
            h[nums[i]] = i
        count[i] = (i - left + 1) + count[i-1]
        res += count[i]
    return res

综上所述，我们提供了两种解决方案，可以在一定程度上满足不同的使用场景。其中，暴力解法可以适用于较小的数组；前缀和 + 哈希表的方法则适用于数据规模较大的情况。