Longest Arithmetic Progression Sequence in Java

An array arr[] is given, and the task is to find the length of the longest sequence in the array such that the sequence forms the arithmetic progression.

Example 1:

Input: int arr[] = {30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140};

Output: 12

Explanation: The sequence of numbers 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140 form the arithmetic progression sequence where the common difference is 10, and the total numbers in the sequence is 12.

Example 2:

Input: int arr[] = {15, 7, 20, 9, 14, 15, 25, 30, 90, 100, 35, 40};

Output: 6

Explanation: The sequence of numbers 15, 20, 25, 30, 35, 40 forms the arithmetic progression sequence where the common difference is 5 and the total numbers in the sequence are 6.

Let's discuss various approaches to solve the problem.

Naive Approach

The naive or simple approach is to consider each pair one by one and treat the elements of the pair as the first two elements (assume the first two elements are: a1 and a2) of the arithmetic progression. Using the first two elements, we can get a common difference (a2 - a1). Using this common difference, we can get the subsequent elements of the arithmetic progression. While finding the subsequent elements, we can also keep the count of elements (countEle) for that arithmetic progression. We will find this count (countEle) for each pair and then will do the comparison for finding the longest arithmetic sequence. Observe the following program.

FileName: LongestArithmeticProgression.java

public class LongestArithmeticProgression
{
// a method for finding the larger number between i & j
public int findMaxNo(int i, int j)
{
int maxNo;
return maxNo = (i > j) ? i : j;
}

public int findLongestApSeq(int arr[], int size)
{

// two or less than two elements always form 
// the arithmetic progression
if(size <= 2)
{
return size;
}

int ans = -1;

// loop for picking the first element of the
// arithemtic progression
for(int i = 0; i < size - 2; i++)
{

// loop for picking the second element of the
// arithemtic progression
for(int j = i + 1; j < size - 1; j++)
{
// finding the common difference
int comDiff = arr[j] - arr[i];

// multiple is 2 becuase the third element
// is first element + 2 * common difference
int multiple = 2;

// the first two loops has fixed the 
// first two elements of the arithmetic progresssion
int countEle = 2;

// loop for picking the subsequent elements (3rd, 4th, 5th, ..., so on)
// of the arithmetic progression
for(int k = j + 1; k < size; k++)
{
if((arr[i] + multiple * comDiff) == arr[k])
{
// element found hence increment the count
countEle = countEle + 1;

// 4th element of an arithmetic progression
// is defined as: a[i] + 3 * common difference
multiple = multiple + 1;
}
}


ans = findMaxNo(ans, countEle);

}
}

return ans;
}
// main method
public static void main(String argvs[]) 
{
// creating an object of the class LongestArithmeticProgression
LongestArithmeticProgression obj = new LongestArithmeticProgression();

// input array
int inputArr[] = {30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140};

int size = inputArr.length;

int longestSeq = obj.findLongestApSeq(inputArr, size);

System.out.println("For the following array: ");
for(int k = 0; k < size; k++)
{
System.out.print(inputArr[k] + " ");
}
System.out.println("\n");
System.out.println("The length of the longest arithmetic progression sequence is: " + longestSeq);

int inputArr1[] = {15, 7, 20, 9, 14, 15, 25, 30, 90, 100, 35, 40};

size = inputArr1.length;

longestSeq = obj.findLongestApSeq(inputArr1, size);

System.out.println("\n");

System.out.println("For the following array: ");
for(int k = 0; k < size; k++)
{
System.out.print(inputArr1[k] + " ");
}
System.out.println("\n");
System.out.println("The length of the longest arithmetic progression sequence is: " + longestSeq);


}
}

Output:

For the following array: 
30 40 50 60 70 80 90 100 110 120 130 140 

The length of the longest arithmetic progression sequence is: 12


For the following array: 
15 7 20 9 14 15 25 30 90 100 35 40 

The length of the longest arithmetic progression sequence is: 6

Complexity Analysis: In the above program, three for-loops have been nested. Therefore, the time complexity of the above program O(n³), where n is the total number of the elements present in the input array. The space complexity of the above program is constant, i.e., O(1).

Since the O(n³) time complexity of the program is too high, it is required to reduce the time complexity using some optimization. The following approach shows the same.

Dynamic Programming Approach

FileName: LongestArithmeticProgression1.java

// import statement for the HashMap
import java.util.HashMap;

public class LongestArithmetic1
{
// a method for finding the larger number between i & j
public int findMaxNo(int i, int j)
{
int maxNo;
return maxNo = (i > j) ? i : j;
}
public int findLongestApSeq(int arr[], int size)
{
// two or less than two elements always form 
// the arithmetic progression
if(size <= 2)
{
return size;
}
// creating a 2-d array whose row and column both
// are equal to the size of the input array
// Here, dp[i][j] means an arithmetic progression
// whose last two elements are arr[i] and arr[j], where i < j
int dp[][] = new int[size][size];
// using the hash map we have reduced the nesting of loop from 3 degree to
// 2 degree
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
int ans = 0;
// loop for picking the second last element of the 
// arithmetic progression
for(int i = 0; i < size; i++)
{
// loop for picking the last element of the 
// arithemetic progression
for(int j = i + 1; j < size; j++)
{
// any two elements can be the  
// part of the arithmetic progression
dp[i][j] = 2;
// for an AP consisiting of three elements
// reqEle is the first element
// arr[i] is the second and arr[j] is the third element
int reqEle = 2 * arr[i] - arr[j];

if(hm.containsKey(reqEle))
{
// retrieving the index of the reqEle
int idx = hm.get(reqEle);
dp[i][j] = findMaxNo(dp[i][j], dp[idx][i] + 1);
ans = findMaxNo(ans, dp[i][j]);
}
}
// putting the arr[i] and its index i
// in the hashmap so that it is used later 
hm.put(arr[i], i);
}
return ans;
}
// main method
public static void main(String argvs[]) 
{
// creating an object of the class LongestArithmetic1
LongestArithmetic1 obj = new LongestArithmetic1();

// input array
int inputArr[] = {30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140};

int size = inputArr.length;

int longestSeq = obj.findLongestApSeq(inputArr, size);

System.out.println("For the following array: ");
for(int k = 0; k < size; k++)
{
System.out.print(inputArr[k] + " ");
}
System.out.println("\n");
System.out.println("The length of the longest arithmetic progression sequence is: " + longestSeq);

int inputArr1[] = {15, 7, 20, 9, 14, 15, 25, 30, 90, 100, 35, 40};

size = inputArr1.length;

longestSeq = obj.findLongestApSeq(inputArr1, size);
System.out.println("\n");
System.out.println("For the following array: ");
for(int k = 0; k < size; k++)
{
System.out.print(inputArr1[k] + " ");
}
System.out.println("\n");
System.out.println("The length of the longest arithmetic progression sequence is: " + longestSeq);
}
}

Output:

For the following array: 
30 40 50 60 70 80 90 100 110 120 130 140 

The length of the longest arithmetic progression sequence is: 12

For the following array: 
15 7 20 9 14 15 25 30 90 100 35 40 

The length of the longest arithmetic progression sequence is: 6

Complexity Analysis: In the above program, two for-loops have been nested. Therefore, the time complexity of the above program O(n²), where n is the total number of the elements present in the input array. We have also used the two-dimensional array which makes the space complexity of the program O(n²).

Even, we can do more optimization to reduce the space complexity. The following approach shows the same.

Using Two Pointers Approach

In this approach, we will fix the middle element of the arithmetic progression and will try to find out the previous and the next element of the progression. It will be done using two pointers. However, before doing that we also need to sort the array. It is because two pointers approach will not work if the given array is not sorted.

FileName: LongestArithmeticProgression2.java

// import statement for the Arrays
import java.util.Arrays;

public class LongestArithmetic2
{

public int findLongestApSeq(int arr[], int size)
{

// two or less than two elements always form 
// the arithmetic progression
if(size <= 2)
{
return size;
}

int ans = -1;
int dp[] = new int[size];


for(int j = 0; j < size; j++)
{
dp[j] = 2;
}

Arrays.sort(arr);
// loop for picking the middle element 
for (int i = size - 2; i >= 0; i--)
{
// two pointer approach
// j for the previous elements
// k for the next elements
int j = i - 1;
int k = i + 1;
while (j >= 0 && k < size)
{

if (arr[j] + arr[k] == 2 * arr[i])
{
dp[i] = Math.max(dp[k] + 1, dp[i]);
ans = Math.max(ans, dp[i]);
j = j - 1;
k = k + 1;
}

// if the sum is less than the twice of the middle 
// element increase the value by incremeting the 
//  k pointer
else if (arr[j] + arr[k] < 2 * arr[i])
{
k = k + 1;
}

// if the value is more than the twice of the middle 
// element decrease the value by decrementing the j pointer
else
{
j = j - 1;
}
}

}

return ans;
}
// main method
public static void main(String argvs[]) 
{
// creating an object of the class LongestArithmetic2
LongestArithmetic2 obj = new LongestArithmetic2();

// input array
int inputArr[] = {30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140};

int size = inputArr.length;

int longestSeq = obj.findLongestApSeq(inputArr, size);

System.out.println("For the following array: ");
for(int k = 0; k < size; k++)
{
System.out.print(inputArr[k] + " ");
}
System.out.println("\n");
System.out.println("The length of the longest arithmetic progression sequence is: " + longestSeq);

int inputArr1[] = {15, 7, 20, 9, 14, 15, 25, 30, 90, 100, 35, 40};

size = inputArr1.length;

longestSeq = obj.findLongestApSeq(inputArr1, size);

System.out.println("\n");

System.out.println("For the following array: ");
for(int k = 0; k < size; k++)
{
System.out.print(inputArr1[k] + " ");
}
System.out.println("\n");
System.out.println("The length of the longest arithmetic progression sequence is: " + longestSeq);


}
}

Output:

For the following array: 
30 40 50 60 70 80 90 100 110 120 130 140 

The length of the longest arithmetic progression sequence is: 12


For the following array: 
15 7 20 9 14 15 25 30 90 100 35 40 

The length of the longest arithmetic progression sequence is: 6

Complexity Analysis: The time complexity is the same as above. However, we have only used a single dimensional array for accomplishing the task. Therefore, we have reduced the space complexity to O(n), where n is the total number of the elements present in the input array.

Next TopicTypes of Sockets in Java

← prev next →