Longest common subarray in the given two arrays

A Space Optimized Solution of LCS

Last Updated : 18 Nov, 2024

Given two strings, s1 and s2, the task is to find the length of the Longest Common Subsequence. If there is no common subsequence, return 0.

Examples:

Input: s1 = “ABCDGH”, s2 = “AEDFHR”
Output: 3
Explanation: The longest subsequence present in both strings is "ADH".
Input: s1 = “AGGTAB”, s2 = “GXTXAYB”
Output: 4
Explanation: The longest subsequence present in both strings is "GTAB".

We have discussed a typical dynamic programming-based solution for LCS.

How to find the length of LCS in O(n) auxiliary space?

One important observation in the above simple implementation is, in each iteration of the outer loop we only need values from all columns of the previous row. So there is no need to store all rows in our dp matrix, we can just store two rows at a time and use them. In that way, used space will be reduced from dp[m+1][n+1] to dp[2][n+1].

The recurrence relation for the Longest Common Subsequence (LCS) problem is:
If the last character of s1 and s2 match:
dp[i][j] = 1 + dp[i-1][j-1]
if the last characters of s1 and s2 do not match, we take the maximum of two cases:
1. exclude the last character of s1
2. exclude the last char of s2
dp[i][j] = max(dp[i-1][j],dp[i][j-1])
Base Case: when the length of either s1 or s2 is 0, LCS is 0.
for i = 0 or j = 0 dp[i][j] = 0
In the recurrance relation one things that we can observe is for finding the current state dp[i][j] we don't need to store the entire table, we only need to store the current row and the previous row because each value at position (i, j) in the table only depends on:
The value directly above it (dp[i-1][j]),
The value directly to the left (dp[i][j-1]),
The value diagonally left above it (dp[i-1][j-1]).
Since only the previous row and the current row are required to compute the LCS, we can reduce the space complexity by using just two rows instead of the entire table. We use a 2D array of size 2 x (n+1) to store only two rows at a time.
We have used two array to store the previous and current row, prev for previous row and curr for current row, once the iteration for current row is done, we will set prev = curr, so that curr row can serve as prev for next index.

C++

// C++ program to find the longest common subsequence of two strings
// using space optimization

#include <bits/stdc++.h>
using namespace std;

int lcs(string& s1, string& s2) {
   
    int n = s1.size();
    int m = s2.size();

    // Initialize two vectors to store the current 
  	// and previous rows of the DP table
    vector<int> prev(m + 1, 0), cur(m + 1, 0);

    // Base case is covered as we have initialized 
  	// the prev and cur vectors to 0.

    for (int ind1 = 1; ind1 <= n; ind1++) {
        for (int ind2 = 1; ind2 <= m; ind2++) {
            if (s1[ind1 - 1] == s2[ind2 - 1]) {
              
                // Characters match, increment LCS length
                cur[ind2] = 1 + prev[ind2 - 1];
            }
            else
                // Characters don't match, consider the
              	// maximum from above or left
                cur[ind2] = max(prev[ind2], cur[ind2 - 1]);
        }
      
        // Update the previous row with the current row
        prev = cur;
    }
  
    // Return the length of the Longest Common Subsequence
    return prev[m];
}
int main() {

    string s1 = "AGGTAB";
    string s2 = "GXTXAYB";
    int res = lcs(s1, s2);
    cout << res;
    return 0;
}

Java

// Java program to find the longest common subsequence of
// two strings using space optimization

class GfG {

    static int lcs(String s1, String s2) {
      
        int n = s1.length();
        int m = s2.length();

        // Create arrays to store the LCS lengths
        int prev[] = new int[m + 1];
        int cur[] = new int[m + 1];

        // Iterate through the strings and calculate LCS
        // lengths
        for (int ind1 = 1; ind1 <= n; ind1++) {
            for (int ind2 = 1; ind2 <= m; ind2++) {

                // If the characters at the current indices
                // are the same, increment the LCS length
                if (s1.charAt(ind1 - 1)
                    == s2.charAt(ind2 - 1))
                    cur[ind2] = 1 + prev[ind2 - 1];
              
                // If the characters are different, choose
                // the maximum LCS length by either
                // excluding a character in s1 or excluding
                // a character in s2
                else
                    cur[ind2] = Math.max(prev[ind2],
                                         cur[ind2 - 1]);
            }
          
            // Update the 'prev' array to the values of
            // 'cur' for the next iteration
            prev = (int[])(cur.clone());
        }

        // Return the length of the Longest Common
        // Subsequence (LCS)
        return prev[m];
    }

    public static void main(String[] args) {

        String s1 = "AGGTAB";
        String s2 = "GXTXAYB";
        int res = lcs(s1, s2);
        System.out.println(res);
    }
}

Python

# Python program to find the longest common subsequence (LCS)
# using space optimization


def lcs(s1, s2):
    n = len(s1)
    m = len(s2)

    # Initialize two arrays, 'prev' and 'cur',
    # to store the DP values
    prev = [0] * (m + 1)
    cur = [0] * (m + 1)

    # Loop through the characters of both strings
    # to compute LCS
    for ind1 in range(1, n + 1):
        for ind2 in range(1, m + 1):
            if s1[ind1 - 1] == s2[ind2 - 1]:
              
                # If the characters match, increment
                # LCS length by 1
                cur[ind2] = 1 + prev[ind2 - 1]
            else:
              
                # If the characters do not match, take 
                # the maximum of LCS
                # by excluding one character from s1 or s2
                cur[ind2] = max(prev[ind2], cur[ind2 - 1])

        # Update 'prev' to be the same as 'cur' for the 
        # next iteration
        prev = cur[:]

    # The value in 'prev[m]' represents the length of the 
    # Longest Common Subsequence
    return prev[m]


if __name__ == "__main__":
    s1 = "AGGTAB"
    s2 = "GXTXAYB"
    print(lcs(s1, s2))

// C# program to find the longest common subsequence (LCS)
// using space optimization

using System;

class GfG {

    static int lcs(string s1, string s2) {
        int n = s1.Length;
        int m = s2.Length;

        // Initialize two arrays to store the current
        // and previous rows of the DP table
        int[] prev = new int[m + 1];
        int[] cur = new int[m + 1];

        // Base case is implicitly handled as the arrays are
        // initialized to 0

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (s1[i - 1] == s2[j - 1]) {
                  
                    // Characters match, increment LCS
                    // length
                    cur[j] = 1 + prev[j - 1];
                }
                else {
                  
                    // Characters don't match, consider the
                    // maximum from above or left
                    cur[j] = Math.Max(prev[j], cur[j - 1]);
                }
            }

            // Update the previous row with
          	// the current row
            Array.Copy(cur, prev, m + 1);
        }

        // Return the length of the Longest Common
        // Subsequence
        return prev[m];
    }

    static void Main() {

        string s1 = "AGGTAB";
        string s2 = "GXTXAYB";
        int res = lcs(s1, s2);
        Console.WriteLine(res);
    }
}

JavaScript

// JavaScript program to find the longest common subsequence
// (LCS) using space optimization

function lcs(s1, s2) {
    const n = s1.length;
    const m = s2.length;

    // Initialize arrays 'prev' and 'cur' to store dynamic
    // programming results, both initialized with 0
    const prev = new Array(m + 1).fill(0);
    const cur = new Array(m + 1).fill(0);

    // Base case is already covered as 'prev' and 'cur' are
    // initialized to 0.

    // Populating the 'cur' array using nested loops
    for (let ind1 = 1; ind1 <= n; ind1++) {
        for (let ind2 = 1; ind2 <= m; ind2++) {
            if (s1[ind1 - 1] === s2[ind2 - 1]) {
                cur[ind2] = 1 + prev[ind2 - 1];
            }
            else {
                cur[ind2]
                    = Math.max(prev[ind2], cur[ind2 - 1]);
            }
        }
        
        // Update 'prev' with the values of 'cur' for the
        // next iteration
        prev.splice(0, m + 1, ...cur);
    }

    // The result is stored in the last element of the
    // 'prev' array
    return prev[m];
}

const s1 = "AGGTAB";
const s2 = "GXTXAYB";
const res = lcs(s1, s2);
console.log(res);

Output

Time Complexity : O(m*n), where m is the length of string s1 and n is the length of string s2.
Auxiliary Space: O(2n), Only two 1D arrays are used, each of size m+1.

Using Single Array - O(m*n) Time and O(n) Space

In this approach, the space complexity is further optimized by using a single DP array, where:
dp[j] represents the value of dp[i-1][j] (previous row's value) before updating. During the computation, dp[j] is updated to represent the current row value dp[i][j]
Now the recurrance relations become:
if the characters s1[i-1] and s2[j-1] match, dp[j] = 1+ prev. Here, prev is a temporary variable storing the diagonal value (dp[i-1][j-1]).
If the characters don't match, dp[j] = max(dp[j-1], dp[j]). Here dp[j] represents the value of dp[i-1][j] before updating and dp[j-1] represents the value of dp[i-1][j].

C++

// C++ program to find the longest common subsequence of two strings
// using space optimization
 
#include <iostream>
#include <vector>
using namespace std;

int lcs(string &s1, string &s2) {
  
    int m = s1.length(), n = s2.length();

    // dp vector is initialized to all zeros
    // This vector stores the LCS values for the current row.
    // dp[j] represents LCS of s1[0..i] and s2[0..j]
    vector<int> dp(n + 1, 0);

    // i and j represent the lengths of s1 and s2 respectively
    for (int i = 1; i <= m; ++i) {

        // prev stores the value from the previous
        // row and previous column (i-1), (j -1)
        // Used to keep track of LCS[i-1][j-1] while updating dp[j]
        int prev = dp[0];

        for (int j = 1; j <= n; ++j) {

            // temp temporarily stores the current
            // dp[j] before it gets updated
            int temp = dp[j];

            // If characters match, add 1 to the value
            // from the previous row and previous column
            // dp[j] = 1 + LCS[i-1][j-1]
            if (s1[i - 1] == s2[j - 1])
                dp[j] = 1 + prev;
            else
                // Otherwise, take the maximum of the
                // left (dp[j-1]) and top (dp[j]) values
                dp[j] = max(dp[j - 1], dp[j]);

            // Update prev for the next iteration
            // This keeps the value of the previous
          // row (i-1) for future comparisons
            prev = temp;
        }
    }

    // The last element of the vector contains the length of the LCS
    // dp[n] stores the length of LCS of s1[0..m] and s2[0..n]
    return dp[n];
}

int main() {
    string s1 = "AGGTAB", s2 = "GXTXAYB";
    cout << lcs(s1, s2);
    return 0;
}

Java

// Java program to find the longest common subsequence of two strings
// using space optimization
  
class GfG {
   
    static int lcs(String s1, String s2) {
        int m = s1.length();
        int n = s2.length();
        
        // dp array is initialized to all zeros
        int[] dp = new int[n + 1];

        // i and j represent the lengths of s1 and s2 respectively
        for (int i = 1; i <= m; ++i) {
          
            // prev stores the value from the previous 
            // row and previous column (i-1), (j -1)
            int prev = dp[0];  
      
            for (int j = 1; j <= n; ++j) {
              
                // temp temporarily stores the current 
                // dp[j] before it gets updated
                int temp = dp[j];  
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                  
                    // If characters match, add 1 to the value 
                    // from the previous row and previous column
                    dp[j] = 1 + prev;  
                } else {
                  
                    // Otherwise, take the maximum of the 
                    // left and top values
                    dp[j] = Math.max(dp[j - 1], dp[j]);  
                }
              
                // Update prev for the next iteration
                prev = temp;  
            }
        }

        // The last element of the array contains 
      	// the length of the LCS
        return dp[n];
    }

    public static void main(String[] args) {
        String s1 = "AGGTAB";
        String s2 = "GXTXAYB";
        int res = lcs(s1, s2);
        System.out.println(res);
    }
}

Python

# Python program to find the longest common subsequence of two strings
# using space optimization
 
def lcs(s1, s2):
    m = len(s1)
    n = len(s2)
    
    # dp array is initialized to all zeros
    dp = [0] * (n + 1)

    # i and j represent the lengths of s1 
    # and s2 respectively
    for i in range(1, m + 1):
      
        # prev stores the value from the previous 
        # row and previous column (i-1), (j -1)
        prev = dp[0]
      
        for j in range(1, n + 1):
          
            # temp temporarily stores the current 
            # dp[j] before it gets updated
            temp = dp[j]
            if s1[i - 1] == s2[j - 1]:
              
                # If characters match, add 1 to the value 
                # from the previous row and previous column
                dp[j] = 1 + prev
            else:
              
                # Otherwise, take the maximum of the 
                # left and top values
                dp[j] = max(dp[j - 1], dp[j])
                
            # Update prev for the next iteration
            prev = temp
      
    # The last element of the list contains
    # the length of the LCS
    return dp[n]
 
if __name__ == "__main__":
    s1 = "AGGTAB"
    s2 = "GXTXAYB"
    res = lcs(s1, s2)
    print(res)

// C# program to find the longest common subsequence of two strings
// using space optimization
 
using System;

class GfG {
   
    static int lcs(string s1, string s2) {
        int m = s1.Length;
        int n = s2.Length;
        
        // dp array is initialized to all zeros
        int[] dp = new int[n + 1];

        // i and j represent the lengths of 
       // s1 and s2 respectively
        for (int i = 1; i <= m; ++i) {
          
            // prev stores the value from the previous 
            // row and previous column (i-1), (j -1)
            int prev = dp[0];
      
            for (int j = 1; j <= n; ++j) {
              
                // temp temporarily stores the current 
                // dp[j] before it gets updated
                int temp = dp[j];
                if (s1[i - 1] == s2[j - 1]) {
                  
                    // If characters match, add 1 to the value 
                    // from the previous row and previous column
                    dp[j] = 1 + prev;
                } else {
                  
                    // Otherwise, take the maximum of the 
                    // left and top values
                    dp[j] = Math.Max(dp[j - 1], dp[j]);
                }
              
                // Update prev for the next iteration
                prev = temp;
            }
        }

        // The last element of the array 
      	// contains the length of the LCS
        return dp[n];
    }
 
    static void Main() {
        string s1 = "AGGTAB";
        string s2 = "GXTXAYB";
        int res = lcs(s1, s2);
        Console.WriteLine(res);
    }
}

JavaScript

// JavaScript program to find the longest common subsequence of two strings
// using space optimization
  
function lcs(s1, s2) {
    const m = s1.length;
    const n = s2.length;

    // dp array is initialized to all zeros
    const dp = Array(n + 1).fill(0);

    // i and j represent the lengths of s1 and s2
    // respectively
    for (let i = 1; i <= m; ++i) {

        // prev stores the value from the previous
        // row and previous column (i-1), (j -1)
        let prev = dp[0];

        for (let j = 1; j <= n; ++j) {

            // temp temporarily stores the current
            // dp[j] before it gets updated
            const temp = dp[j];
            if (s1[i - 1] === s2[j - 1]) {

                // If characters match, add 1 to the value
                // from the previous row and previous column
                dp[j] = 1 + prev;
            }
            else {

                // Otherwise, take the maximum of the
                // left and top values
                dp[j] = Math.max(dp[j - 1], dp[j]);
            }

            // Update prev for the next iteration
            prev = temp;
        }
    }

    // The last element of the array 
    // contains the length of the LCS
    return dp[n];
}

const s1 = "AGGTAB";
const s2 = "GXTXAYB";
const res = lcs(s1, s2);
console.log(res);

Output

Longest common subarray in the given two arrays

kartik

Improve

Article Tags :

Practice Tags :

A Space Optimized Solution of LCS

How to find the length of LCS in O(n) auxiliary space?

Using Single Array - O(m*n) Time and O(n) Space

Similar Reads

Problems on LCS

Thank You!

What kind of Experience do you want to share?