413. 等差数列划分

413. 等差数列划分

1. 题目描述
题目链接

如果一个数列至少有三个元素，并且任意两个相邻元素之差相同，则称该数列为等差数列。
例如，以下数列为等差数列:
1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9
以下数列不是等差数列。
1, 1, 2, 5, 7
数组 A 包含 N 个数，且索引从0开始。数组 A 的一个子数组划分为数组 (P, Q)，P 与 Q 是整数且满足 0<=P<Q<N 。
如果满足以下条件，则称子数组(P, Q)为等差数组：
元素 A[P], A[p + 1], …, A[Q - 1], A[Q] 是等差的。并且 P + 1 < Q 。
函数要返回数组 A 中所有为等差数组的子数组个数。
示例:
A = [1, 2, 3, 4]
返回: 3, A 中有三个子等差数组: [1, 2, 3], [2, 3, 4] 以及自身 [1, 2, 3, 4]。

2. 题目分析
动态分析题，题目说了一大段，意思就是，从给定数组中，找到所有的等差数组，并且计算这些等差数列的子数组个数的总和。
题目给出的事例其实具有误导性，乍一看还以为是只存在一组等差数列，然后求子数组的和。其实不然，给定数组中可以存在多个等差数组，然后求每个等差数组的子数组的和。
比如这个数组：[1, 2, 3, 4, 6, 10, 13, 16]。那么其中就存在两个等差数组，即[1, 2, 3, 4]，[10, 13, 16]。

那么这题目存在两个难点，一是怎么识别当前节点处于一个等差数组中，二是一个等差数组，存在多少子数组。

• 难点一的解决方法：用一个公差d标记当前节点的前面元素是处于一个等差数组中，所以只要判断d == A[i] - A[i-1]，其实你也可以一直用A[i] - A[i-1] == A[i+1] - A[i]判断前后元素是否是处于同一个等差数列中，只是这样会增加以下计算量、
• 难点二的解决方法：找规律，即从一个等差数组（n个元素）对应f(n)个子数组。
  等差数组{1,2,3,4,5,6,7…}

等差数组的元素个数	子数组个数（也必须是等差数组）
3	1
4	3
5	6
6	10
7	15
。。。	。。。
n	f(n-1) + (n-2)

从表格中可以发现规律，即等差数组的元素个数n与子数组个数的关系是， f(n) = f(n-1) + (n-2) 。

3. 解决思路

状态：f(n)表示等差数组的元素个数为n时，子数组个数。
等差数组的元素个数n与子数组个数的关系是， f(n) = f(n-1) + (n-2) （n>=3）；

4. 代码实现（java）

package com.algorithm.leetcode.dynamicAllocation;

/**
 * Created by 凌 on 2018/12/13.
 * 描述：413. 等差数列划分
 */
public class NumberOfArithmeticSlices {
    public static void main(String[] args) {
//        int[] nums = {1, 2, 3, 4};
        int[] nums = {1, 2, 3, 4, 7, 10, 13, 16};
        int result = numberOfArithmeticSlices(nums);
        System.out.println(result);
    }
    public static int numberOfArithmeticSlices(int[] A) {
        if (A == null || A.length < 3){
            return 0;
        }
        int number = 0;//统计当前部分等差数列的元素个数
        int temp = 0;//统计当前部分等差数列的子数组个数
        int numberOfArithmeticSlices = 0;//总的等差数列的子数组个数
        int d = Integer.MAX_VALUE;//差值
        int i = 1;
        while (i < A.length) {
            //如果d = Integer.MAX_VALUE，那么说明前一个元素不再与前面元素是同一个等差数列，所以需要重新判定新的等差数列
            if (d == Integer.MAX_VALUE && i+1 < A.length && A[i] - A[i-1] == A[i+1] - A[i]){
                d = A[i] - A[i-1];
                i+=2;
                number = 3;
                temp+=(number-2);
            }
            //如果前面已经判定了是等差数列，所以只需要判定是否延续等差数列
            if (d != Integer.MAX_VALUE && i < A.length  && d == A[i] - A[i-1]){
                number++;
                temp+=(number-2);
                i++;
            }
            //判定是否延续等差数列
            if (i < A.length && d != A[i] - A[i-1]){
                numberOfArithmeticSlices += temp;
                temp=0;
                number=0;
                d = Integer.MAX_VALUE;
                i++;
            }
        }
        numberOfArithmeticSlices += temp;
        return numberOfArithmeticSlices;
    }
}