给你一个整数数组nums，要求该数组中所有为等差数组的子数组个数（等差数组子数组，指的是至少3个数的连续数组成等差数列）

算法思路：

- 定义一个变量count，用于记录等差数组子数组的个数。
- 从数组的第二个元素开始遍历，假设当前遍历到的元素下标为i。
- 定义两个变量prev和diff，分别表示以i-1为结尾的最长等差数组的结尾元素和公差。初始情况下，prev为nums[0]，diff为nums[1]-nums[0]。
- 定义一个变量len，记录当前等差数组的长度，初始值为2。
- 遍历nums数组，从下标2开始，依次判断当前元素与prev的差值是否等于diff。如果相等，说明当前元素是等差数组中的一员，将len加1。否则，说明当前元素不在等差数组中，需要更新prev和diff，并判断当前等差数组的长度是否大于等于3，如果大于等于3，将count加1。然后，将len重置为2，将prev更新为当前元素，diff更新为当前元素与prev的差值。
- 遍历完成后，需要再次判断当前等差数组的长度是否大于等于3，如果大于等于3，将count加1。

时间复杂度：O(n)
空间复杂度：O(1)

Python 代码：

相关问题

c++如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。 例如，[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差数列。 给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组个数.子数组 是数组中的一个连续序列。

这是一道比较经典的数组问题，可以用动态规划来解决。我们可以定义一个数组 $dp$，其中 $dp_i$ 表示以第 $i$ 个元素结尾的等差数列的个数。假设我们已经计算出了 $dp_0, dp_1, \cdots, dp_{i-1}$，现在要计算 $dp_i$，我们可以枚举 $j, k$，其中 $j<i<k$，并检查 $nums_j$ 和 $nums_k$ 与 $nums_i$ 是否构成等差数列，如果是，那么 $dp_i$ 的值就可以加上 $dp_{j}$，因为以 $j$ 结尾的等差数列加上一个元素 $nums_i$ 后，仍然是等差数列。

具体实现时，我们需要用一个变量 $diff$ 来记录当前等差数列的差值，初值为 $nums_1-nums_0$，并用一个变量 $ans$ 来记录等差数列的个数。然后从第三个元素开始遍历数组，如果当前元素与前面两个元素构成等差数列，那么我们将 $ans$ 加一，并将当前元素加入等差数列中；否则，我们将 $diff$ 更新为当前元素与前面一个元素的差值，并将当前元素加入等差数列中。

下面是使用 C++ 实现的代码：

给你一个整数数组 nums，返回 nums 中最长等差子序列的长度。 回想一下，nums 的子序列是一个列表 nums[i1], nums[i2], ..., nums[ik] ，且 0 <= i1 < i2 < ... < ik <= nums.length - 1。并且如果 seq[i+1] - seq[i]( 0 <= i < seq.length - 1) 的值都相同，那么序列 seq 是等差的。

你可以使用动态规划来解决这个问题。首先，需要创建一个二维数组 dp，其中 dp[i][j] 表示以 nums[i] 和 nums[j] 为结尾的等差子序列的长度。因为等差子序列至少包含两个元素，所以 dp[i][j] 的初始值应该为 2。

接下来，对于每个 j，需要找到其前面的一个元素 i，使得 nums[j]-nums[i] 等于之前的公差，也就是说，nums[i] + (nums[j] - nums[i]) = 2 * nums[j] - nums[i]。如果存在这样的 i，那么 dp[i][j] 应该等于 dp[k][i] + 1，其中 k 表示 i 和 j 之前的元素，也就是说，i 和 j 是从 k 和 i 延伸出来的等差子序列的结尾。如果不存在这样的 i，那么 dp[i][j] 应该是 2。

最终的答案应该是 dp 数组中的最大值。

以下是代码实现：

def longestArithSeqLength(nums: List[int]) -> int:
    n = len(nums)
    if n < 3:
        return n
    
    dp = [[2] * n for _ in range(n)]
    ans = 2
    
    for i in range(n):
        for j in range(i+1, n):
            for k in range(i):
                if nums[i] + nums[j] == 2 * nums[k]:
                    dp[i][j] = max(dp[i][j], dp[k][i]+1)
            ans = max(ans, dp[i][j])
    
    return ans

值得注意的是，上面的代码时间复杂度是 $O(n^3)$ 的，需要使用一些优化技巧才能通过该题。