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

413. 等差数列划分


思路:题目:

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;
}

446. 等差数列划分 II - 子序列

思路:力扣解题思路:等差数列划分 纠错记录_第1张图片
我一看题目,简单啊,和上一题基本一样,就是数组间的间隔不要求是连续的,只要间隔是等差的就可以了,在外循环套一个遍历间隔的循环即可:

    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;
}

你可能感兴趣的:(力扣解题思路:等差数列划分 纠错记录)