[LeetCode] 413. Arithmetic Slices

最新推荐文章于 2025-08-04 20:35:07 发布

原创最新推荐文章于 2025-08-04 20:35:07 发布 · 200 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #dynamic-programming

算法专栏收录该内容

19 篇文章

订阅专栏

本文介绍了一种算法，用于计算给定数组中等差子序列的数量。通过动态规划的方法，文章提供了两种实现思路，包括如何维护当前等差序列长度及如何计算最终的等差子序列总数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

[LeetCode] 413. Arithmetic Slices

题目描述

A sequence of number is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.

For example, these are arithmetic sequence:

1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9
The following sequence is not arithmetic.

1, 1, 2, 5, 7

A zero-indexed array A consisting of N numbers is given. A slice of that array is any pair of integers (P, Q) such that 0 <= P < Q < N.

A slice (P, Q) of array A is called arithmetic if the sequence:
A[P], A[p + 1], …, A[Q - 1], A[Q] is arithmetic. In particular, this means that P + 1 < Q.

The function should return the number of arithmetic slices in the array A.

Example:

A = [1, 2, 3, 4]

return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.

分析

这里需要找到一个数列中等差的子数列的个数，因此可以通过计算每两个数之间的差值，当差值一直相等时，说明这是一个连续的等差子数列，直到差值变化再重新看。

class Solution {
public:
  int numberOfArithmeticSlices(vector<int>& A) {
    int size = A.size();
    int result = 0;
    vector<int> dp(size, 0);
    if (size < 3) return 0;
    int prev = A[1] - A[0], len = 1;
    for (int i = 2; i < size; i++) {
      if (A[i] - A[i - 1] == prev) {
        len++;
      } else {
        result += len * (len - 1) / 2;
        len = 1;
      }
      prev = A[i] - A[i - 1];
    }
    result += len * (len - 1) / 2;
    return result;
  }
};

如果使用动态规划解决这个问题，则查看当前位置的前后是否为等差数列，如果是，那么当前位置与之前的数形成等差数列的个数为前一个位置加一，把各个位置形成的等差数列相加就是最后的结果。

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) {
        int size = A.size();
        int result = 0;
        vector<int> dp(size, 0);
        if (size < 3) return 0;
        for (int i = 1; i < size - 1; i++) {
            if (A[i] - A[i - 1] == A[i + 1] - A[i]) {
                dp[i] = dp[i - 1] + 1;
            }
            result += dp[i];
        }
        return result;
    }
};