# LCS formed by consecutive segments of at least length K

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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 cnti-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.

## C++

 `// CPP program to find the Length of Longest  ` `// subsequence formed by consecutive segments ` `// of at least length K ` `#include ` `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. `

Output:

```8
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.