Longest Odd-Even Subsequence in Java

The longest odd-even subsequence in Java is a problem in which one has to find a subsequence in a non-negative array of size s, such that the subsequence contains alternate odd and even numbers in an alternate manner. Thus, one has to find the count of numbers present in the longest subsequence that has the alternative sequence of the odd and even numbers. Note that the subsequence can start either with an even or with an odd number. Let's understand it with the help of some examples.

For example:

Input: int arr[] = {15, 16, 19, 14, 17, 18, 21, 30, 78}, //Size s = 9

Output: 8

Explanation: The required longest subsequence is (15, 16, 19, 14, 17, 18, 21, 30) or (15, 16, 19, 14, 17, 18, 21, 78), and the count of element in the subsequence is 8.

Input: int arr[] = {11, 112, 12, 122, 15, 130, 131, 140, 117, 111}, //Size s = 10

Output: 7

Explanation: The required longest subsequence is (11, 112, 15, 130, 131, 140, 117) or (11, 112, 15, 130, 131, 140, 111), or there can be another subsequence too, and the count of the elements in the subsequence is 7.

Approach

There are two approaches to find out the longest odd-even subsequence. One is the brute force approach, also known as the naïve approach. The other is the efficient approach using dynamic programming. Let's start with the naïve one.

Naïve Approach

In this approach, we will find out the all-possible subsequences of the given array. Then, for all the computed subsequences, we will filter out the longest odd-even subsequence. For better understanding, observe the following program.

FileName: OddEvenSeq.java

// importing Array List
import java.util.ArrayList;

public class OddEvenSeq
{
public ArrayList<Integer> al;
public ArrayList<ArrayList<Integer>> al2;

// constructor of the class
OddEvenSeq()
{
// initializing the 1-d and 2-d array list
al = new ArrayList<Integer>();
al2 = new ArrayList<ArrayList<Integer>>();

}

// a method that finds out all of the subsequences
// of the input array a of the size s
public void findSubSequence(int a[], int i, int s, ArrayList<ArrayList<Integer>> store)
{
// handling the base case
if(i >= s)
{
ArrayList<Integer> temp = new ArrayList<Integer>();

for(int j = 0; j < al.size(); j++)
{
temp.add(al.get(j));
}
// storing the array list temp in the store
// temp is a subsequence of the input array a[]
store.add(temp);
return;
}

// recursively computing all of the subsequences
// there could be only two cases: one is to include
// the element and other is to exclude the element

al.add(a[i]); // including the element


// after adding the element recur to the 
// next element
findSubSequence(a, i + 1, s, store);
if(al.size() > 0)
{
// excluding the element
al.remove(al.size() - 1);

}

// after removing the element recur for the next element
findSubSequence(a, i + 1, s, store);

}

// a method that finds out the count of elements
// present in the longest subsequence
public int longestSubSequenceCount()
{
int s1 = al2.size();
int count = 0;
int ans = 0;
for(int i = 0; i < s1; i++)
{
// resetting the count to 0
// for the next iteration
count = 0;

// taking one of the array list
// present in the 2-d array list
ArrayList<Integer> temp = al2.get(i);
int s2 = temp.size();

// it is find that keeps track of 
// whether the next element should be odd or even
// find has only two values or states 0 & 1
// 0 means even state and 1 means odd state
int find = -1;
for(int j = 0; j < s2; j++)
{
int num = temp.get(j);
if(find == -1)
{

if((num & 1) == 1)
{
// the current element is odd
// hence the value of find is 1
find = 1;
}
else
{
// the current element is even
// hence the value of find is 0
find = 0;
}

count = count + 1;
ans = Math.max(ans, count);

// if the current element is odd
// the next element has to be even and vice versa
// therefore, we need to toggle the find.
// the following statement does the same
find = 1 - find;
}

else if((num & 1) == find)
{
// control reaching here means
// the current element matches
// the state of find, i.e., if the 
// current element is odd then find is 1
// and if the current element is even then 
// find is 0
count = count + 1;

// again toggle
find = 1 - find;
ans = Math.max(ans, count);
}

// if the state of find does not 
// match with the state of the current 
// element, then terminate the loop
else
{

break;
}
}
}

return ans;
}

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

// input array
int a[] = {15, 16, 19, 14, 17, 18, 21, 30, 78};
int size = a.length;
obj.findSubSequence(a, 0, size, obj.al2);
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(a[i] + " ");    
}
System.out.println("\n");

int ans = obj.longestSubSequenceCount();

System.out.println("The longest odd even subsequence is: " + ans); 

// clearing the array lists
obj.al2.clear();
obj.al.clear();

// another input array
int a1[] = {11, 112, 12, 122, 15, 130, 131, 140, 117, 111};
size = a1.length;
System.out.println();

obj.findSubSequence(a1, 0, size, obj.al2);
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(a1[i] + " ");    
}
System.out.println("\n");

ans = obj.longestSubSequenceCount();

System.out.println("The longest odd even subsequence is: " + ans);


}
}

Output:

For the input array: 
15 16 19 14 17 18 21 30 78 

The longest odd even subsequence is: 8

For the input array: 
11 112 12 122 15 130 131 140 117 111 

The longest odd even subsequence is: 7

Complexity Analysis: In the above program, there are two choices; one is to include the element, and the other is to exclude the element. Therefore, the time complexity of the above program is exponential, which is O(2ⁿ), where n is the total number of elements present in the array. The time complexity O(2ⁿ) is quite huge. Therefore, the above program is not suitable for the input array that contains a lot of elements. Also, the program is taking a lot of extra space, which is also exponential O(2ⁿ).

Implementation: Dynamic Programming

Let longLen(j) be the length of the Longest Odd-Even Subsequence (LOES) that is ending at the index j so that the a[j] is the last element of the LOES. Thus, longLen(j) can be written recursively as: longLen(j) = 1 + max(longLen(i)), where 0 < i < j and (a[i] < a[j]) and (a[i]+a[j]) % 2 != 0; or longLen(j) = 1, if there is no such i exists. In order to compute the longest odd even subsequence for the given array, it is required to return the max(longLen(j)) where 0 < j < size.

The following program implements the dynamic programming approach for the above-mentioned recursive relation.

FileName: OddEvenSeq1.java

public class OddEvenSeq1
{

    public int longOddEvenSeq(int a[], int size)
    {
        // loes[j] keeps the longest odd even
        // subsequence which is ending at a[j]
        int[] loes = new int[size];
 
        // to keep the size of the longest odd
        // even subsequence
        int maximumLen = 0;
 
        // Initialize LOES values for all indexes
        for (int j = 0; j < size; j++)
        {
            loes[j] = 1;
        }
 
        // Computing the optimized LOES values
        // in the bottom up manner
        for (int j = 1; j < size; j++)
        {
            for (int i = 0; i < j; i++)
            {
                // in an alternating sequence of odd and even numbers
                // the sum of any two numbers, where one is odd and other is even
                // is always odd
                if ((a[j] + a[i]) % 2 != 0 && loes[j] < loes[i] + 1)
                {
                    loes[j] = loes[i] + 1;
                }
            }
        }
 
        // Picking the maximum of all the LOES values
        for (int k = 0; k < size; k++)
        {
            if (maximumLen < loes[k])
            {
                maximumLen = loes[k];
            }
        }
 
        // returning the maximum length
        return maximumLen;
    }


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

int a[] = {15, 16, 19, 14, 17, 18, 21, 30, 78};
int size = a.length;

System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(a[i] + " ");    
}
System.out.println("\n");

int ans = obj.longOddEvenSeq(a, size);

System.out.println("The longest odd even subsequence is: " + ans); 



}
}

Output:

For the input array: 
15 16 19 14 17 18 21 30 78 

The longest odd even subsequence is: 8

Complexity Analysis: The above program uses the 2-level nesting of the for-loops. Therefore, the time complexity of the above program is O(n²), where n is the total number of elements present in the array. The program is taking an array as the extra memory, which is of the size n. Therefore, the space complexity of the above program is O(n).

Next TopicJava Subtract Days from Current Date

← prev next →