Longest Harmonious Subsequence in Java

An array of n integers is given to us. The task is to find the size of the longest harmonious subsequence of the array. A subsequence is said to be harmonious if the difference between the maximum value element and the minimum value element in the subsequence is 1.

Example 1:

Input

int inArr1[] = {11, 12, 12, 13, 14, 15, 11, 11, 11, 11}

Output

Explanation:

The longest harmonious subsequence is {11, 12, 12, 11, 11, 11, 11} whose size is 7. Hence, the output is 7.

Example 2:

Input

int inArr1[] = {0, 1, 5, 8, 10, 19, 15, 25, 30, 40, 45, 7, 11}

Output

Explanation:

The longest harmonious subsequences are {0, 1} or {7, 8}, and {10, 11}. Each harmonious subsequence is of size 2. Hence, the output is 2.

Brute Force Approach: Using Bit Masking

The concept is to generate all of the possible subsequences with the help of the bit masking technique. For every subsequence, check whether the subsequence is the Harmonious subsequence or not. Take out the maximum length of all of the valid subsequences that are possible.

Observe the following steps:

Step 1: Take a variable ans. Initialize it with the value 0. The variable "ans" will contain the final answer.

Step 2: Iterate from 'j' = 0 to '2^len - 1', where 'len is the length of the input array, 'inputArr[]'.

Initialize three integers 'minVal, 'maxVal', and 'currLen' with INT_MAX, INT_MIN, and 0, respectively, for keeping the minimum and maximum values of the current subsequence and the length of the current subsequence respectively.
Iterate from 'k' = 0 to 'len - 1':
- If a k^th bit of j is set and 'MIN_VALUE' is < inputArr[k], then update the 'MIN_VALUE' to inputArr[k].
- If a k^th bit of j is set and 'MAX_VALUE' is > inputArr[k], then update the 'MAX_VALUE' to inputArr[k].
- Increment the 'currLen' since we are considering the current element in the subsequence.
If the difference between the 'MIN_VALUE' and 'MAX_VALUE' is 1, then it is a valid subsequence. Therefore, update the 'ans' to the maximum of 'ans' and 'currLen'.

Step 3: Return the answer 'ans'.

Now, let's observe the implementation of the above algorithm.

FileName: LongestHarmoniousSubsequence.java

public class LongestHarmoniousSubsequence
{
public static int lengthOfLHS(int[] inputArr, int len)
{
int ans = 0; // for storing the final answer

// Iterating from j = 0 to 2 ^ len - 1
for (int j = 0; j < (1l << len); j++)
{
    // Variables for storing the minimum, maximum values and 
    // the length of the subsequence, respectively

    int minVal = Integer.MAX_VALUE;
    int maxVal = Integer.MIN_VALUE;
    int currLen = 0;

    // Iterating over the input array array
    for (int k = 0; k < len; k++)
    {
        // If the kth bit of j is set
        if ((j & (1 << k)) != 0)
        {
            currLen = currLen + 1;
            minVal = Math.min(minVal, inputArr[k]);
            maxVal = Math.max(maxVal, inputArr[k]);
        }
    }

    // If the maximum difference is 1, then it is a harmonic subsequence
    // The rest of the other conditions are there to avoid overflow of Integer
    if (maxVal != Integer.MIN_VALUE && minVal != Integer.MAX_VALUE && maxVal - minVal == 1)
    {
        ans = Math.max(ans, currLen);
    }
}

// returning the final answer
return ans;
}


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

// input array
int inputArr[] = {11, 12, 12, 13, 14, 15, 11, 11, 11, 11};
int sze = inputArr.length; // computing size of the input array

System.out.println("For the input array: ");
for(int i = 0 ; i < sze; i++)
{
System.out.print(inputArr[i] + " ");
}
System.out.println( );
// invoking the method lengthOfLHS() for computing the 
// longest length of the Harmonic subsequence
int ans = obj.lengthOfLHS(inputArr, sze);

System.out.println("The length of the longest Harmonic subsequence is: " + ans);

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

// input array
int inputArr1[] = {0, 1, 5, 8, 10, 19, 15, 25, 30, 40, 45, 7, 11};
sze = inputArr1.length; // computing size of the input array

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

// invoking the method lengthOfLHS() for computing the 
// longest length of the Harmonic subsequence
ans = obj.lengthOfLHS(inputArr1, sze);
System.out.println("The length of the longest Harmonic subsequence is: " + ans);



}
}

Output:

For the input array: 
11 12 12 13 14 15 11 11 11 11 
The length of the longest Harmonic subsequence is: 7


For the input array: 
0 1 5 8 10 19 15 25 30 40 45 7 11 
The length of the longest Harmonic subsequence is: 2

Complexity Analysis: The program is generation all of the binary values from 0 to 2^len - 1. After that, the program is iteration through the array. Therefore, the overall time complexity of the program is O(len x 2^len), where 'len' is the length of the input array. Also, the program is not using extra space, making the space complexity of the program O(1).

The time complexity of the program clearly indicates that it is not suitable for larger inputs. Therefore, it is required to do some optimization to reduce the time complexity.

Optimization

The concept is to pivot every element of the array and then take only those elements that are equal or have a difference of 1 such that the maximum difference in the subsequence becomes 1.

Observe the following steps.

Step 1: Take a variable ans. Initialize it with the value 0. The variable "ans" will contain the final answer.

Step 2: Iterate from 'j' = 0 to 'len - 1':

Initialize 'currLen' with 0. The variable 'currLen' is used to keep the length of the current subsequence.
Take a Boolean flag 'flg' and assign a value false to it, and the value will be true if there is a possibility to make a harmonic subsequence.
Iterate from 'k' = 0 to 'len - 1':
- If the element at the k^th index is the same as the element at the j^th index, then increase the 'currLen' by 1.
- If the element at the k^th index is 1 larger than the element at the j^th index, then increase the 'currLen' by 1 and set the flag 'flg' to true as the maximum difference of the current subsequence is 1.
If the flag 'flg' is true, then update the answer 'ans' to the maximum of 'ans' and 'currLen'.

Step 3: Return 'ans' as the final answer.

Now, let's observe the implementation of the above algorithm.

FileName: LongestHarmonioussubsequence1.java

public class LongestHarmoniousSubsequence1
{
public int lengthOfLHS(int[] inputArr, int len)
{
int ans = 0; // for storing the final answer

// Iterating over the array.
for (int j = 0; j < len; j++)
{
    boolean flg = false;
    int currLen = 0;

    // Iterating over the input array.
    for (int k = 0; k < len; k++)
    {
        // If the kth element of the array is 
        // the same as jth element of the array.
        if (inputArr[k] == inputArr[j])
        {
            currLen = currLen + 1;
        }
        
        // If kth element of the array is 1 larger than the jth element of 
        // the array, then it is the harmonic subsequence.
        if (inputArr[k] == 1 + inputArr[j])
        {
            currLen = currLen + 1;
            flg = true;
        }
    }
    
    // If it is a harmonic subsequence.
    if (flg)
    {
        ans = Math.max(ans, currLen);
    }
    
}

// returning the final answer
return ans;
}

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

// input array
int inputArr[] = {11, 12, 12, 13, 14, 15, 11, 11, 11, 11};
int sze = inputArr.length; // computing size of the input array

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

// invoking the method lengthOfLHS() for computing the 
// longest length of the Harmonic subsequence
int ans = obj.lengthOfLHS(inputArr, sze);

System.out.println("The length of the longest Harmonic subsequence is: " + ans);

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

// input array
int inputArr1[] = {0, 1, 5, 8, 10, 19, 15, 25, 30, 40, 45, 7, 11};
sze = inputArr1.length; // computing size of the input array

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

// invoking the method lengthOfLHS() for computing the 
// longest length of the Harmonic subsequence
ans = obj.lengthOfLHS(inputArr1, sze);
System.out.println("The length of the longest Harmonic subsequence is: " + ans);



}
}

Output:

For the input array: 
11 12 12 13 14 15 11 11 11 11 
The length of the longest Harmonic subsequence is: 7


For the input array: 
0 1 5 8 10 19 15 25 30 40 45 7 11 
The length of the longest Harmonic subsequence is: 2

Complexity Analysis: In the program, each element of the input array is getting pivoted. Also, a loop is iterating through the array that takes O(len) time. Thus, the overall time complexity of the program O(len²), where 'len' is the size of the input array. The space complexity of the program is constant, i.e., O(1).

Another Approach: Using HashMap

The approach is to keep the number of times an element occurs in a HashMap. In every iteration, check two things:

Check whether inputArr[j] + 1 is there in the HashMap or not. If it is present, then the current length of the subsequence will be the total number of occurrences of inputArr[j] + the total number of occurrences of (inputArr[j] + 1).
Check whether inputArr[j] - 1 is there in the HashMap or not. If it is present, then the current length of the subsequence will be the number of occurrences of inputArr[j] + the total number of occurrences of (inputArr[j] - 1).

The steps are as follows:

Step 1: Take a variable ans. Initialize it with the value 0. The variable "ans" will contain the final answer.

Step 2: Define a HashMap 'freqHashMap' for keeping the number of times each element is occurring in the input array inputArr[].

Step 3: Iterate from 'j' = 0 to 'len - 1':

Increase the count of inputArr[j] in the HashMap.
If inputArr[j] + 1 is present in the HashMap, i.e., freqHashMap[inputArr[j] + 1] >0, then update the 'ans' to the maximum of 'ans' and (freqHashMap [inputArr[j]] + freqHashMap[inputArr[j] + 1]).
If inputArr[j] - 1 is present in the HashMap, i.e., freqHashMap[inputArr[j] - 1] >0, then update the 'ans' to the maximum of 'ans' and (freqHashMap[inputArr[j]] + freqHashMap[inputArr[j] - 1]).

Step 4: return 'ans'.

The following program implements the above-mentioned steps.

FileName: LongestHarmonioussubsequence2.java

// importing HashMap and Map that are required
// in the program
import java.util.HashMap;
import java.util.Map;

public class LongestHarmonioussubsequence2
{
public int lengthOfLHS(int[] inputArr, int len)
{
int ans = 0; // for storing the final answer

// HashMap to store the count of every element.
Map<Integer, Integer> freqHashMap = new HashMap<Integer, Integer>();

// Iterating over the input array.
for (int j = 0; j < len; j++)
{
    // Incrementing the count of inputArr[j].
    int cnt = (freqHashMap.containsKey(inputArr[j])) ? freqHashMap.get(inputArr[j]) : 0;
    freqHashMap.put(inputArr[j], cnt + 1);

    
    //    If inputArr[j] + 1 is present, then it means it is possible to create a harmonic subsequence
    //    using all the occurrences of inputArr[j] and inputArr[j] + 1.
    
    if (freqHashMap.containsKey(inputArr[j] + 1))
    {
        ans = Math.max(ans, freqHashMap.get(inputArr[j]) + freqHashMap.get(inputArr[j] + 1));

    }

    // If inputArr[j] - 1 is present, then it means it is possible to make a harmonic subsequence
    // using all of the occurences of the inputArr[j] and inputArr[j] - 1.
    if (freqHashMap.containsKey(inputArr[j] - 1))
    {
        ans = Math.max(ans, freqHashMap.get(inputArr[j]) + freqHashMap.get(inputArr[j] - 1));
    }
}

return ans;
}

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

// input array
int inputArr[] = {11, 12, 12, 13, 14, 15, 11, 11, 11, 11};
int sze = inputArr.length; // computing size of the input array

System.out.println("For the input array: ");
for(int i = 0 ; i < sze; i++)
{
System.out.print(inputArr[i] + " ");
}
System.out.println( );
// invoking the method lengthOfLHS() for computing the 
// longest length of the Harmonic subsequence
int ans = obj.lengthOfLHS(inputArr, sze);

System.out.println("The length of the longest Harmonic subsequence is: " + ans);

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

// input array
int inputArr1[] = {0, 1, 5, 8, 10, 19, 15, 25, 30, 40, 45, 7, 11};
sze = inputArr1.length; // computing size of the input array

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

// invoking the method lengthOfLHS() for computing the 
// longest length of the Harmonic subsequence
ans = obj.lengthOfLHS(inputArr1, sze);
System.out.println("The length of the longest Harmonic subsequence is: " + ans);



}
}

Output:

For the input array: 
11 12 12 13 14 15 11 11 11 11 
The length of the longest Harmonic subsequence is: 7


For the input array: 
0 1 5 8 10 19 15 25 30 40 45 7 11 
The length of the longest Harmonic subsequence is: 2

Complexity Analysis: In program, a loop is used to iterate over the input array and incrementing the count of each element in the HashMap that has the amortized time complexity of O(1). Therefore, the overall time complexity of the program is O(N). Also, the HashMap can grow maximum up to the size of the input array. Therefore, the overall space complexity of the program also O(N). Here, N is the total number of elements in the input array.

Next TopicCount OR Pairs in Java

← prev next →