Longest Common Subsequence in Java

The longest subsequence common to all the given sequences is referred to as Longest Common Subsequence. The reason for using the LCS is to restrict the element of the subsequences from occupying the consecutive position within the original sequences.

A sequence that appears in the same relative order, either contiguous or non-contiguous way is known as a subsequence.

For example, if we have two sequences, such as "KTEURFJS" and "TKWIDEUJ", the longest common subsequence will be "TEUJ" of length 4.

In Java, there are two ways to implement the LSC program, i.e., using the recursive method and using dynamic programming. Both the ways have a different implementation.

Using Dynamic Programming

This approach is a tabulated implementation for the Longest Common Subsequence. In order to find the Longest Common Subsequence, we use the following steps:

First, we create a table of dimensions (p + 1)*(q + 1) where p and q are the lengths of the given sequences. In the created table, we set 0 to the first row and the first column.
All the remaining cells of the table are filled by using the following steps:
1. If the characters of the corresponding row and the column are the same and matched successfully, fill the current cell with 1 to the diagonal element and point an arrow to the diagonal cell.
2. If the characters are not matched, we fill the current cell with the value of the previous column and previous row element. The arrow points to the cell having maximum value, and when the value in both the cells is equal, the arrow will point to any of them.
3. We repeat step 2 until the complete table is not filled.
4. The length of the longest common subsequence is the value present in the last row and the last column.
5. In order to get the LCS, we follow the direction of the arrow from the last element. The elements corresponding to the brackets() are form the longest common subsequence.

Let's implement the code of the Longest Common Subsequence using dynamic programming by following the above steps.

LCSExample1.java

// import required classes and packages
import Java.util.*; 
import java.io.*; 
import java.util.Scanner;

// create LCSExample1 class to find the Longest Common Subsequence
class LCSExample1 {
	
	// create findLengthOfLCS() method that returns the longest common sequences
	public static String findLengthOfLCS(String str1, String str2, int p, int q) {
    
		// create a matrix which act as a table for LCS
		int[][] tableForLCS = new int[p + 1][q + 1];

		// fill the table in the bottom up way
		for (int i = 0; i <= p; i++) {
			for (int j = 0; j <= q; j++) {
				if (i == 0 || j == 0)
					tableForLCS[i][j] = 0;	// Fill each cell corresponding to first row and first column with 0
				else if (str1.charAt(i - 1) == str2.charAt(j - 1))
					tableForLCS[i][j] = tableForLCS[i - 1][j - 1] + 1;	// add 1 in the cell of the previous row and column and fill the current cell with it 
				else
					tableForLCS[i][j] = Math.max(tableForLCS[i - 1][j], tableForLCS[i][j - 1]);	//find the maximum value from the cell of the previous row and current column and the cell of the current row and previous column  
			}
		}
	
		int index = tableForLCS[p][q];
		int temp = index;

		char[] longestCommonSubsequence = new char[index + 1];
		longestCommonSubsequence[index] = '\0';

		int i = p, j = q;
		String lcs ="";
		while (i > 0 && j > 0) {
			if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
				
				longestCommonSubsequence[index - 1] = str1.charAt(i - 1);
				i--;
				j--;
				index--;
			}
			else if (tableForLCS[i - 1][j] > tableForLCS[i][j - 1])
				i--;
			else
				j--;
		}
		
		for (int k = 0; k <= temp; k++)
			lcs = lcs + longestCommonSubsequence[k];
			
		return lcs;
	}
	public static void main(String[] args) {
		
		String str1, str2, LCS;
		
		Scanner sc= new Scanner(System.in); //System.in is a standard input stream.
		System.out.print("Enter first sequence: ");
		str1 = sc.nextLine(); //reads string.
		
		System.out.print("Enter second sequence: ");
		str2 = sc.nextLine(); //reads string.
		
		int p = str1.length();
		int q = str2.length();
		
		LCS = findLengthOfLCS(str1, str2, p, q);
		
		System.out.print("Sequence1: " + str1 + "\nSequence2: " + str2);
		System.out.println("\nLCS: "+LCS);
		
	}
}

Output

Using Recursive Implementation

Let's understand another example of LCS that uses recursive implementation. In this example, we take two sequences from the user and return or print the length of the Longest Common Subsequence.

LCSExample2.java

// import required classes and packages
import java.util.*; 
import java.io.*; 
import java.util.Scanner;

// create LCSExample2 class to find the length of the Longest Common Subsequence
public class LCSExample2 {
  
    // create getLengthOfLCS() method that returns length of the LCS
    public static int getLengthOfLCS(char[] str1, char[] str2, int p, int q)
    {
		//check the length of the sequence
        if (p == 0 || q == 0)
            return 0;
		
		// when the last character of both the sequences are equal
        if (str1[p - 1] == str2[q - 1])
            return 1 + getLengthOfLCS(str1, str2, p - 1, q - 1);
        else
            return maxValue(getLengthOfLCS(str1, str2, p, q - 1), getLengthOfLCS(str1, str2, p - 1, q));
    }
  
    // create maxValue() method that returns the length of the sequence having maximum length from both of them 
    static int maxValue(int length1, int length2)
    {
        if (length1 > length2)
			return length1;
		else
			return length2;
    }
	
	//main() method starts
    public static void main(String[] args)
    {
        String string1, string2;
		
		//create Scanner class object to get sequence from the user
		Scanner sc = new Scanner(System.in); //System.in is a standard input stream.
		System.out.print("Enter first sequence: ");
		string1 = sc.nextLine(); //reads string.
		
		System.out.print("Enter second sequence: ");
		string2 = sc.nextLine(); //reads string.
		
		char[] str1 = string1.toCharArray();
        char[] str2 = string2.toCharArray();
		
		int p = string1.length();
		int q = string2.length();
  
        System.out.println("Length of the Longest Common Subsequence is: "+ getLengthOfLCS(str1, str2, p, q));
    }
}

Output