leetCode 413. 等差数列划分[中等]

题目

如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。

例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。

子数组 是数组中的一个连续序列。

示例 1：

输入：nums = [1,2,3,4]
输出：3
解释：nums 中有三个子等差数组：[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。

示例 2：

输入：nums = [1]
输出：0

提示：

• 1 <= nums.length <= 5000
• -1000 <= nums[i] <= 1000

动态规划解决

按照题的要求当数组的长度小于3的时候是不能构成等差数列的。如果数组长度小于3，我们直接返回0。

定义一维数组dp，其中dp[i]表示以nums[i]为等差数列最后一个元素的等差数列个数。很明显，

如果nums[i]可以和前面的数字可以构成等差数列，那么dp[i]=dp[i-1]+1，如下图所示：

如果nums[i]和前面的数字不能构成等差数列，那么dp[i]肯定是等于0的，我们还需要重新计算新的等差值diff。
我们统计的时候只需要把所有等差数列的个数相加即可，看代码：

    public int numberOfArithmeticSlices(int[] nums) {
        int length = nums.length;
        //如果构不成等差数列，返回0
        if (length < 3)
            return 0;
        int[] dp = new int[length];
        //等差数列的个数
        int count = 0;
        //等差数列的差值
        int diff = nums[1] - nums[0];
        for (int i = 2; i < length; i++) {
            if (nums[i] - nums[i - 1] == diff) {
                //如果当前数字和前面的可以构成等差数列，
                //就更新dp和count的值
                dp[i] = dp[i - 1] + 1;
                count += dp[i];
            } else {
                //如果不能和前面的构成等差数列，要重新计算diff
                diff = nums[i] - nums[i - 1];
            }
        }
        return count;
    }

时间复杂度和空间复杂度都是O(n)。

动态规划代码优化

这里空间复杂度还可以降低的，我们看到计算dp[i]的时候，当前值只和前一个dp[i-1]有关，和前面的其他值无关，我们可以使用一个变量pre即可，他表示的是前一个数字可以构成的等差数列长度。看代码：

    public int numberOfArithmeticSlices(int[] nums) {
        int length = nums.length;
        //如果构不成等差数列，返回0
        if (length < 3)
            return 0;
        //等差数列的个数
        int count = 0;
        //等差数列的差值
        int diff = nums[1] - nums[0];
        //前一个构成的等差数列长度
        int pre = 0;
        for (int i = 2; i < length; i++) {
            if (nums[i] - nums[i - 1] == diff) {
                pre += 1;
                count += pre;
            } else {
                //如果不能和前面的构成等差数列，要重新计算diff
                diff = nums[i] - nums[i - 1];
                pre = 0;//注意这里需要重新赋值
            }
        }
        return count;
    }

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

——转载自“数据结构与算法”