Count of AP (Arithmetic Progression) Subsequences in an array
Given an array of n positive integers. The task is to count the number of Arithmetic Progression subsequence in the array. Note: Empty sequence or single element sequence is Arithmetic Progression. 1 <= arr[i] <= 1000000.
Examples:
Input : arr[] = { 1, 2, 3 }
Output : 8
Arithmetic Progression subsequence from the
given array are: {}, { 1 }, { 2 }, { 3 }, { 1, 2 },
{ 2, 3 }, { 1, 3 }, { 1, 2, 3 }.
Input : arr[] = { 10, 20, 30, 45 }
Output : 12
Input : arr[] = { 1, 2, 3, 4, 5 }
Output : 23
Since empty sequence and single element sequence is also arithmetic progression, so we initialize the answer with n(number of element in the array) + 1.
Now, we need to find the arithmetic progression subsequence of length greater than or equal to 2. Let minimum and maximum of the array be minarr and maxarr respectively. Observe, in all the arithmetic progression subsequences, the range of common difference will be from (minarr – maxarr) to (maxarr – minarr). Now, for each common difference, say d, calculate the subsequence of length greater than or equal to 2 using dynamic programming.
Let dp[i] be the number of subsequence that end with arr[i] and have common difference of d. So,
The number of subsequence of length greater than or equal to 2 with common difference d is sum of dp[i] – 1, 0 <= i = 2 with difference d. To speed up, store the sum of dp[j] with arr[j] + d = arr[i] and j < i.
Below is implementation of above idea :
C++
#include<bits/stdc++.h>
#define MAX 1000001
using namespace std;
int numofAP( int a[], int n)
{
int minarr = INT_MAX, maxarr = INT_MIN;
for ( int i = 0; i < n; i++)
{
minarr = min(minarr, a[i]);
maxarr = max(maxarr, a[i]);
}
int dp[n], sum[MAX];
int ans = n + 1;
for ( int d=(minarr-maxarr); d<=(maxarr-minarr); d++)
{
memset (sum, 0, sizeof sum);
for ( int i = 0; i < n; i++)
{
dp[i] = 1;
if (a[i] - d >= 1 && a[i] - d <= 1000000)
dp[i] += sum[a[i] - d];
ans += dp[i] - 1;
sum[a[i]] += dp[i];
}
}
return ans;
}
int main()
{
int arr[] = { 1, 2, 3 };
int n = sizeof (arr)/ sizeof (arr[0]);
cout << numofAP(arr, n) << endl;
return 0;
}
|
Java
import java.util.Arrays;
class GFG {
static final int MAX = 1000001 ;
static int numofAP( int a[], int n)
{
int minarr = + 2147483647 ;
int maxarr = - 2147483648 ;
for ( int i = 0 ; i < n; i++) {
minarr = Math.min(minarr, a[i]);
maxarr = Math.max(maxarr, a[i]);
}
int dp[] = new int [n];
int sum[] = new int [MAX];
int ans = n + 1 ;
for ( int d = (minarr - maxarr);
d <= (maxarr - minarr); d++)
{
Arrays.fill(sum, 0 );
for ( int i = 0 ; i < n; i++) {
dp[i] = 1 ;
if (a[i] - d >= 1 &&
a[i] - d <= 1000000 )
dp[i] += sum[a[i] - d];
ans += dp[i] - 1 ;
sum[a[i]] += dp[i];
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 };
int n = arr.length;
System.out.println(numofAP(arr, n));
}
}
|
Python3
MAX = 1000001
def numofAP(a, n):
minarr = + 2147483647
maxarr = - 2147483648
for i in range (n):
minarr = min (minarr, a[i])
maxarr = max (maxarr, a[i])
dp = [ 0 for i in range (n + 1 )]
ans = n + 1
for d in range ((minarr - maxarr), (maxarr - minarr) + 1 ):
sum = [ 0 for i in range ( MAX + 1 )]
for i in range (n):
dp[i] = 1
if (a[i] - d > = 1 and a[i] - d < = 1000000 ):
dp[i] + = sum [a[i] - d]
ans + = dp[i] - 1
sum [a[i]] + = dp[i]
return ans
arr = [ 1 , 2 , 3 ]
n = len (arr)
print (numofAP(arr, n))
|
C#
using System;
class GFG {
static int MAX = 1000001;
static int numofAP( int []a, int n)
{
int minarr = +2147483647;
int maxarr = -2147483648;
int i;
for (i = 0; i < n; i++)
{
minarr = Math.Min(minarr, a[i]);
maxarr = Math.Max(maxarr, a[i]);
}
int []dp = new int [n];
int []sum = new int [MAX];
int ans = n + 1;
for ( int d = (minarr - maxarr);
d <= (maxarr - minarr); d++)
{
for (i = 0; i < MAX; i++)
sum[i]= 0;
for ( i = 0; i < n; i++)
{
dp[i] = 1;
if (a[i] - d >= 1 &&
a[i] - d <= 1000000)
dp[i] += sum[a[i] - d];
ans += dp[i] - 1;
sum[a[i]] += dp[i];
}
}
return ans;
}
public static void Main()
{
int []arr = {1, 2, 3};
int n = arr.Length;
Console.WriteLine(numofAP(arr, n));
}
}
|
Javascript
<script>
let MAX = 1000001;
function numofAP(a, n)
{
let minarr = +2147483647;
let maxarr = -2147483648;
for (let i = 0; i < n; i++) {
minarr = Math.min(minarr, a[i]);
maxarr = Math.max(maxarr, a[i]);
}
let dp = new Array(n);
let sum = new Array(MAX);
let ans = n + 1;
for (let d = (minarr - maxarr);
d <= (maxarr - minarr); d++)
{
sum.fill(0);
for (let i = 0; i < n; i++) {
dp[i] = 1;
if (a[i] - d >= 1 &&
a[i] - d <= 1000000)
dp[i] += sum[a[i] - d];
ans += dp[i] - 1;
sum[a[i]] += dp[i];
}
}
return ans;
}
let arr = [ 1, 2, 3 ];
let n = arr.length;
document.write(numofAP(arr, n));
</script>
|
Output :
8
Time complexity: O(n*d) given an array of n positive integers and d is the difference between the maximum and minimum value in the array.
Auxiliary Space: O(MAX)
Last Updated :
12 Sep, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...