算法（动态规划）----等差数列划分

等差数列划分

数组 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]。

双指针法

创建两个指针i，j（初始化时i=0,j=1），先以前两个数的差值 (differ=A[i+1]=A[i]) 作为判断等差数列的条件，j不断向后移动，

• 若当前位置上元素的和前一个元素的差等于differ 即A[j]-A[j-1]==differ，这说明i到j之间依然是等差数列，count统计等差数列元素个数，计数加1
• 若当前位置上元素的和前一个元素的差不等于differ，则说明j走到当前位置已经无法组成等差数列，此时移动i到j-1位置，然后继续移动。
• 如果count>=2，这说明i到j-1这一段的等差数列长度>=3，此时拥有的子数列个数为：count*(count-1)/2
• 所以总的等差数列个数就是整个数组中每一段等差数列中拥有的子数列的和即num+=count*(count-1)/2
• 虽然是双循环，但只遍历了一次数组，时间复杂度为O(n)

代码：

public int numberOfArithmeticSlices(int[] A) {
		int num = 0;
		int i = 0;
		int j = 1;
		while (i < A.length - 2 && j < A.length) {
			int differ = A[i + 1] - A[i];
			int count = 0;
			for (j = i + 1; j < A.length; j++) {
				if (A[j] - A[j - 1] == differ) {
					count++;
				} else {
					i = j - 1;
					break;
				}
			}
			if (count >= 2) {
				num += count * (count - 1) / 2;
			}
		}
		return num;
}

动态规划

我们分析会发现，i位置上等差数列的个数就等于i-1位置上等差数列的个数加1

如图所示：

 

 

 

代码：

//动态规划
	public int numberOfArithmeticSlices(int[] A) {
		if(A.length<=0){
			return 0;
		}
		int[] dp=new int[A.length];
		int num=0;
		dp[0]=0;
		dp[1]=0;
		for(int i=2;i<A.length;i++){
			if(A[i]-A[i-1]==A[i-1]-A[i-2]){
				dp[i]=dp[i-1]+1;
			}
			num+=dp[i];
		}
		return num;
		
	}

还可以对空间进行优化 

//优化空间，dp[i]只和dp[i-1]有关，只需要一个变量保存即可
	public  int numberOfArithmeticSlices(int[] A) {
		if(A.length<=0){
			return 0;
		}
		int dp=0;
		int num=0;
		
		for(int i=2;i<A.length;i++){
			if(A[i]-A[i-1]==A[i-1]-A[i-2]){
				dp=dp+1;
			}else {
				dp=0;
			}
			num+=dp;
		}
		return num;
		
	}