力扣解题思路：等差数列划分 纠错记录

A = [0, 1, 2, 3, 4]

return: 6, for 3 arithmetic slices in A:

[0, 1, 2],
[1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3, 4],
[ 1, 2, 3, 4],
[2, 3, 4]

如果相邻的三个数两两做差相等就是等差数列。当 A[i] - A[i-1] == A[i-1] - A[i-2]，那么 [A[i-2], A[i-1], A[i]] 构成一个等差递增子区间。而且在以 A[i-1] 为结尾的递增子区间的后面再加上一个 A[i]，一样可以构成新的递增子区间，此状态和之前的状态有关。自然而然的想到动态规划，先定义动态规划方程，其中dp[i] 表示以 A[i] 为结尾的等差递增子区间的个数。
举例：

dp[2] = 1
    [0, 1, 2]
dp[3] = dp[2] + 1 = 2
    [0, 1, 2, 3], // [0, 1, 2] 之后加一个 3
    [1, 2, 3]     // 新的递增子区间
dp[4] = dp[3] + 1 = 3
    [0, 1, 2, 3, 4], // [0, 1, 2, 3] 之后加一个 4
    [1, 2, 3, 4],    // [1, 2, 3] 之后加一个 4
    [2, 3, 4]        // 新的递增子区间

则动态规划方程如下：

if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
            dp[i] = dp[i - 1] + 1;
 }

那么从0到i的等差数列个数之和自然就是dp[0]…dp[i]之和，我们可以在更新dp数组的时候用sumlai累加最后的结果值，其实我觉得这个好难想呀(っ °Д °;)っ要不是看了别人的思路完全想不到动态方程是这样~
完整的代码如下：

public int numberOfArithmeticSlices(int[] A) {
    int[] dp = new int[A.length];
    int sum = 0;
    for (int i = 2; i < dp.length; i++) {
        if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
            dp[i] = 1 + dp[i - 1];
            sum += dp[i];
        }
    }
    return sum;
}

还可以使用暴力法，先以两个元素为基准，找第三个元素，如果这三个元素为等差数列则找第四个元素，以此内推：

public int numberOfArithmeticSlices(int[] A) {
    int count = 0;
    for (int s = 0; s < A.length - 2; s++) {
        int d = A[s + 1] - A[s];
        for (int e = s + 2; e < A.length; e++) {
            if (A[e] - A[e - 1] == d)
                count++;
            else
                break;//不满足则直接退出循环（因为题目要求等差数列的索引是连续的）
        }
    }
    return count;
}

思路：
我一看题目，简单啊，和上一题基本一样，就是数组间的间隔不要求是连续的，只要间隔是等差的就可以了，在外循环套一个遍历间隔的循环即可：

    public int numberOfArithmeticSlices(int[] A) {
        int res = 0;
        for(int i=1;i<A.length;i++){
            int sum = 0;
            int[] dp = new int[A.length];
            for (int j = 2*i; j < dp.length; j++) {
                if (A[j] - A[j-i] == A[j-i] - A[j-2*i]) {
                    dp[j] = 1 + dp[j - i];
                    sum += dp[j];
                }
            }
            res += sum;
        }  
        return res;
    }

后来才发现我的题目看错了，没有要求间隔一定是等差的，只是数值等差，间隔可以连续也可以不连续(╬▔皿▔)凸

好吧，继续改。还是按照之前的遍历方法吗？基本一致，但是由于上一题只考虑两个相邻元素的差值，所以这个差值是固定的，但是这里就没有相邻元素的限制了，所以我么要先从数组中随机选两个数，然后固定这个差值，也就是我们还是需要两层循环，仍然也是啊按照动态规划的思路，第一个位置保存当前索引，第二个维度表示当前差值，那这个差值多大我不知道，暂定10000吧：

int[][] dp = new int[A.length][10000];

然后就可以像之前那样更新啦，注意这里dp数组的含义和上面的不同，上面的dp是至少三个元素的等差数组个数，而这里的还包含只有两个元素的等差数组的个数（每两个数都能使dp加一）：

for(int i=0;i<A.length;i++){
    for(int j=0;j<i;j++){
        int diff = A[i]-A[j];
        int count = dp[j][diff];
        dp[i][diff] += count + 1;
        sum += count;
    }
}

注意sum每次加的都是count而不是count+1，因为count+1代表的是之前的每个等差数列中每个数列元素个数加一，如果满足三个数等差了，实际上count加了两次，而三个数等差我们应该只加一次(因为只表示一个组，计数1)！！！因为我们的循环中可没有“当等差数组元素大于等于3才计数加一”这种判断，而这个 sum += count;相当于潜在的判断了这个值~

完整代码：

public int numberOfArithmeticSlices(int[] A){
    int[][] dp = new int[A.length][10000];
    int sum = 0;
    for(int i=0;i<A.length;i++){
        for(int j=0;j<i;j++){
            int diff = A[i]-A[j];
            int count = dp[j][diff];
            dp[i][diff] += count + 1;
            sum += count;
        }
    }
    return sum;
}

你以为这样就对了吗？就报错了。。。因为这个10000还是不够，那不如我们直接用map存吧，就不用考虑数组长度了：

public int numberOfArithmeticSlices(int[] A) {
    HashMap<Integer, Integer>[] diffMaps = new HashMap[A.length];
    int sum = 0;
    for(int i = 0;i<A.length;i++){
        HashMap<Integer, Integer> diffMap = new HashMap();
        diffMaps[i] = diffMap;
        long num = A[i];
        for(int j=0;j<i;j++){
            if(num-A[j]>Integer.MAX_VALUE)
                continue;
            if(num-A[j]<Integer.MIN_VALUE)
                continue;
            int diff = (int)(num-A[j]);
            int count = diffMaps[j].getOrDefault(diff, 0);
            diffMaps[i].put(diff,diffMaps[i].getOrDefault(diff, 0)+count+1);
            sum+=count;
        }
    }
    return res;
}