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 =aggayxysdfas2 =aggajxaaasdfak = 4 Output : 8 Explanation:aggasdfais 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 = aggasdfas2 = 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 LCS_{i, 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. **cnt _{i, j}= cnt_{i-1, j-1}+1** when s1[i-1]==s2[j-1]. If characters are not equal then segments are not equal hence mark cnt

_{i, j}as 0.

When

**cnt**, then update the lcs value by adding the value of cnt

_{i, j}>=k_{i-a, j-a}where a is the length of the segments

**a<=cnt**. The answer for the longest subsequence with consecutive segments of at least length k will be stored in

_{i, j}**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 <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.` |

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