Open In App

LCS formed by consecutive segments of at least length K

Improve
Improve
Like Article
Like
Save
Share
Report

Given two strings s1, s2 and K, find the length of the longest subsequence formed by consecutive segments of at least length K.

Examples: 

Input : s1 = aggayxysdfa
        s2 = aggajxaaasdfa 
         k = 4
Output : 8 
Explanation: aggasdfa is the longest
subsequence that can be formed by taking
consecutive segments, minimum of length 4.
Here segments are "agga" and "sdfa" which 
are of length 4 which is included in making 
the longest subsequence. 

Input : s1 = aggasdfa 
        s2 = aggajasdfaxy
         k = 5
Output : 5 

Input: s1 = "aabcaaaa" 
       s2 = "baaabcd"  
        k = 3
Output: 4 
Explanation: "aabc" is the longest subsequence that 
is formed by taking segment of minimum length 3. 
The segment is of length 4. 

Prerequisite: Longest Common Subsequence 

Create a LCS[][] array where LCSi, j denotes the length of the longest common subsequence formed by characters of s1 till i and s2 till j having consecutive segments of at least length K. Create a cnt[][] array to count the length of the common segment. cnti, j= cnti-1, j-1+1 when s1[i-1]==s2[j-1]. If characters are not equal then segments are not equal hence mark cnti, j as 0. 

When cnti, j>=k, then update the lcs value by adding the value of lcsi-a, j-a where a is the length of the segments a<=cnti, j. The answer for the longest subsequence with consecutive segments of at least length k will be stored in lcs[n][m] where n and m are the length of string1 and string2. 

Implementation:

C++




// CPP program to find the Length of Longest
// subsequence formed by consecutive segments
// of at least length K
#include <bits/stdc++.h>
using namespace std;
 
// Returns the length of the longest common subsequence
// with a minimum of length of K consecutive segments
int longestSubsequenceCommonSegment(int k, string s1,
                                           string s2)
{
    // length of strings
    int n = s1.length();
    int m = s2.length();
 
    // declare the lcs and cnt array
    int lcs[n + 1][m + 1];
    int cnt[n + 1][m + 1];
 
    // initialize the lcs and cnt array to 0
    memset(lcs, 0, sizeof(lcs));
    memset(cnt, 0, sizeof(cnt));
 
    // iterate from i=1 to n and j=1 to j=m
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
 
            // stores the maximum of lcs[i-1][j] and lcs[i][j-1]
            lcs[i][j] = max(lcs[i - 1][j], lcs[i][j - 1]);
 
            // when both the characters are equal
            // of s1 and s2
            if (s1[i - 1] == s2[j - 1])
                cnt[i][j] = cnt[i - 1][j - 1] + 1;
 
            // when length of common segment is
            // more than k, then update lcs answer
            // by adding that segment to the answer
            if (cnt[i][j] >= k) {
 
                // formulate for all length of segments
                // to get the longest subsequence with
                // consecutive Common Segment of length
                // of min k length
                for (int a = k; a <= cnt[i][j]; a++)
 
                    // update lcs value by adding segment length
                    lcs[i][j] = max(lcs[i][j],
                                    lcs[i - a][j - a] + a);
                 
            }
        }
    }
 
    return lcs[n][m];
}
 
// driver code to check the above function
int main()
{
    int k = 4;
    string s1 = "aggasdfa";
    string s2 = "aggajasdfa";
    cout << longestSubsequenceCommonSegment(k, s1, s2);
    return 0;
}


Java




// Java program to find the Length of Longest
// subsequence formed by consecutive segments
// of at least length K
 
class GFG {
 
    // Returns the length of the longest common subsequence
    // with a minimum of length of K consecutive segments
    static int longestSubsequenceCommonSegment(int k, String s1,
                                               String s2)
    {
        // length of strings
        int n = s1.length();
        int m = s2.length();
     
        // declare the lcs and cnt array
        int lcs[][] = new int[n + 1][m + 1];
        int cnt[][] = new int[n + 1][m + 1];
     
     
        // iterate from i=1 to n and j=1 to j=m
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
     
                // stores the maximum of lcs[i-1][j] and lcs[i][j-1]
                lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
     
                // when both the characters are equal
                // of s1 and s2
                if (s1.charAt(i - 1) == s2.charAt(j - 1))
                    cnt[i][j] = cnt[i - 1][j - 1] + 1;
     
                // when length of common segment is
                // more than k, then update lcs answer
                // by adding that segment to the answer
                if (cnt[i][j] >= k)
                {
     
                    // formulate for all length of segments
                    // to get the longest subsequence with
                    // consecutive Common Segment of length
                    // of min k length
                    for (int a = k; a <= cnt[i][j]; a++)
     
                        // update lcs value by adding
                        // segment length
                        lcs[i][j] = Math.max(lcs[i][j],
                                        lcs[i - a][j - a] + a);
                     
                }
            }
        }
     
        return lcs[n][m];
    }
     
    // driver code to check the above function
    public static void main(String[] args)
    {
        int k = 4;
        String s1 = "aggasdfa";
        String s2 = "aggajasdfa";
        System.out.println(longestSubsequenceCommonSegment(k, s1, s2));
    }
}
 
// This code is contributed by prerna saini.


Python3




# Python3 program to find the Length of Longest
# subsequence formed by consecutive segments
# of at least length K
 
# Returns the length of the longest common subsequence
# with a minimum of length of K consecutive segments
def longestSubsequenceCommonSegment(k, s1, s2) :
     
    # length of strings
    n = len(s1)
    m = len(s2)
 
    # declare the lcs and cnt array
    lcs = [[0 for x in range(m + 1)] for y in range(n + 1)]
    cnt = [[0 for x in range(m + 1)] for y in range(n + 1)]
 
 
    # iterate from i=1 to n and j=1 to j=m
    for i in range(1, n + 1) :
        for j in range(1, m + 1) :
            # stores the maximum of lcs[i-1][j] and lcs[i][j-1]
            lcs[i][j] = max(lcs[i - 1][j], lcs[i][j - 1])
 
            # when both the characters are equal
            # of s1 and s2
            if (s1[i - 1] == s2[j - 1]):
                cnt[i][j] = cnt[i - 1][j - 1] + 1;
 
            # when length of common segment is
            # more than k, then update lcs answer
            # by adding that segment to the answer
            if (cnt[i][j] >= k) :
                 
                # formulate for all length of segments
                # to get the longest subsequence with
                # consecutive Common Segment of length
                # of min k length
                for a in range(k, cnt[i][j] + 1) :
                     
                    # update lcs value by adding
                    # segment length
                    lcs[i][j] = max(lcs[i][j],lcs[i - a][j - a] + a)
                     
    return lcs[n][m]
 
 
# Driver code 
k = 4
s1 = "aggasdfa"
s2 = "aggajasdfa"
print(longestSubsequenceCommonSegment(k, s1, s2))
 
# This code is contributed by Nikita Tiwari.


C#




// C# program to find the Length of Longest
// subsequence formed by consecutive segments
// of at least length K
using System;
 
class GFG {
 
    // Returns the length of the longest common subsequence
    // with a minimum of length of K consecutive segments
    static int longestSubsequenceCommonSegment(int k, string s1,
                                            string s2)
    {
        // length of strings
        int n = s1.Length;
        int m = s2.Length;
     
        // declare the lcs and cnt array
        int [,]lcs = new int[n + 1,m + 1];
        int [,]cnt = new int[n + 1,m + 1];
     
     
        // iterate from i=1 to n and j=1 to j=m
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
     
                // stores the maximum of lcs[i-1][j] and lcs[i][j-1]
                lcs[i,j] = Math.Max(lcs[i - 1,j], lcs[i,j - 1]);
     
                // when both the characters are equal
                // of s1 and s2
                if (s1[i - 1] == s2[j - 1])
                    cnt[i,j] = cnt[i - 1,j - 1] + 1;
     
                // when length of common segment is
                // more than k, then update lcs answer
                // by adding that segment to the answer
                if (cnt[i,j] >= k)
                {
     
                    // formulate for all length of segments
                    // to get the longest subsequence with
                    // consecutive Common Segment of length
                    // of min k length
                    for (int a = k; a <= cnt[i,j]; a++)
     
                        // update lcs value by adding
                        // segment length
                        lcs[i,j] = Math.Max(lcs[i,j],
                                        lcs[i - a,j - a] + a);
                     
                }
            }
        }
     
        return lcs[n,m];
    }
     
    // driver code to check the above function
    public static void Main()
    {
        int k = 4;
        string s1 = "aggasdfa";
        string s2 = "aggajasdfa";
    Console.WriteLine(longestSubsequenceCommonSegment(k, s1, s2));
    }
}
 
// This code is contributed by vt_m.


Javascript




<script>
 
// JavaScript program to find the Length of Longest
// subsequence formed by consecutive segments
// of at least length K
 
// Returns the length of the longest common subsequence
// with a minimum of length of K consecutive segments
function longestSubsequenceCommonSegment(k, s1, s2)
{
    // length of strings
    var n = s1.length;
    var m = s2.length;
 
    // declare the lcs and cnt array
    var lcs = Array.from(Array(n+1), ()=>Array(m+1).fill(0));
    var cnt = Array.from(Array(n+1), ()=>Array(m+1).fill(0));
 
    // iterate from i=1 to n and j=1 to j=m
    for (var i = 1; i <= n; i++) {
        for (var j = 1; j <= m; j++) {
 
            // stores the maximum of lcs[i-1][j] and lcs[i][j-1]
            lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
 
            // when both the characters are equal
            // of s1 and s2
            if (s1[i - 1] == s2[j - 1])
                cnt[i][j] = cnt[i - 1][j - 1] + 1;
 
            // when length of common segment is
            // more than k, then update lcs answer
            // by adding that segment to the answer
            if (cnt[i][j] >= k) {
 
                // formulate for all length of segments
                // to get the longest subsequence with
                // consecutive Common Segment of length
                // of min k length
                for (var a = k; a <= cnt[i][j]; a++)
 
                    // update lcs value by adding segment length
                    lcs[i][j] = Math.max(lcs[i][j],
                                    lcs[i - a][j - a] + a);
                 
            }
        }
    }
 
    return lcs[n][m];
}
 
// driver code to check the above function
var k = 4;
var s1 = "aggasdfa";
var s2 = "aggajasdfa";
document.write( longestSubsequenceCommonSegment(k, s1, s2));
 
</script>


Output

8

Time Complexity: O(N*M), as we are using nested loops to traverse N*M times.
Auxiliary Space: O(N*M), as we are using extra space for lcs and cnt.

Where N and M are the length of the strings.



Last Updated : 02 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads