# Longest Common Substring | (DP – 27)

Problem Statement: Longest Common Substring

A substring of a string is a subsequence in which all the characters are consecutive. Given two strings, we need to find the longest common substring.

```Example:

```

We need to print the length of the longest common substring.

### Solution :

Approach:

We can modify the approach we used in the article Longest Common Subsequence, in order to find the longest common substring. The main distinguishing factor between the two is the consecutiveness of the characters.

While finding the longest common subsequence, we were using two pointers (ind1 and ind2) to map the characters of the two strings. We will again have the same set of conditions for finding the longest common substring, with slight modifications to what we do when the condition becomes true.

We will try to form a solution in the bottom-up (tabulation) approach. We will set two nested loops with loop variables i and j.

Thinking in terms of consecutiveness of characters

We have two conditions:

• if(S1[i-1] != S2[j-1]), the characters don’t match, therefore the consecutiveness of characters is broken. So we set the cell value (dp[i][j]) as 0.
• if(S1[i-1] == S2[j-1]), then the characters match and we simply set its value to 1+dp[i-1][j-1]. We have done so because dp[i-1][j-1] gives us the longest common substring till the last cell character (current strings -{matching character}). As the current cell’s character is matching we are adding 1 to the consecutive chain.

Note: dp[n][m] will not give us the answer; rather the maximum value in the entire dp array will give us the length of the longest common substring. This is because there is no restriction that the longest common substring is present at the end of both the strings.

Code:

## C++ Code

``````#include <bits/stdc++.h>

using namespace std;

int lcs(string &s1, string &s2){

int n = s1.size();
int m = s2.size();

vector<vector<int>> dp(n+1,vector<int>(m+1,0));

int ans = 0;

for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(s1[i-1]==s2[j-1]){
int val = 1 + dp[i-1][j-1];
dp[i][j] = val;
ans = max(ans,val);
}
else
dp[i][j] = 0;
}
}

return ans;

}

int main() {

string s1= "abcjklp";
string s2= "acjkp";

cout<<"The Length of Longest Common Substring is "<<lcs(s1,s2);
}
``````

Output:

The Length of Longest Common Substring is 3

Time Complexity: O(N*M)

Reason: There are two nested loops

Space Complexity: O(N*M)

Reason: We are using an external array of size ‘N*M)’. Stack Space is eliminated.

## Java Code

``````import java.util.*;

class TUF{
static int lcs(String s1, String s2){

int n = s1.length();
int m = s2.length();

int[][] dp=new int[n+1][m+1];
int ans = 0;

for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(s1.charAt(i-1)==s2.charAt(j-1)){
int val = 1 + dp[i-1][j-1];
dp[i][j] = val;
ans = Math.max(ans,val);
}
else
dp[i][j] = 0;
}
}

return ans;

}

public static void main(String args[]) {

String s1= "abcjklp";
String s2= "acjkp";

System.out.println("The Length of Longest Common Substring is "+lcs(s1,s2));
}
}``````

Output:

The Length of Longest Common Substring is 3

Time Complexity: O(N*M)

Reason: There are two nested loops

Space Complexity: O(N*M)

Reason: We are using an external array of size ‘N*M)’. Stack Space is eliminated.

## Python Code

``````def lcs(s1, s2):
n = len(s1)
m = len(s2)
dp = [[0] * (m + 1) for _ in range(n + 1)]

ans = 0

for i in range(1, n + 1):
for j in range(1, m + 1):
if s1[i - 1] == s2[j - 1]:
val = 1 + dp[i - 1][j - 1]
dp[i][j] = val
ans = max(ans, val)
else:
dp[i][j] = 0

return ans

def main():
s1 = "abcjklp"
s2 = "acjkp"

print("The Length of Longest Common Substring is", lcs(s1, s2))

if __name__ == '__main__':
main()
``````

Output:

The Length of Longest Common Substring is 3

Time Complexity: O(N*M)

Reason: There are two nested loops

Space Complexity: O(N*M)

Reason: We are using an external array of size ‘N*M)’. Stack Space is eliminated.

### Space Optimization

If we look closely, we need values from the previous row: dp[ind-1][ ]

So we are not required to contain an entire array, we can simply have two rows prev and cur where prev corresponds to dp[ind-1] and cur to dp[ind].

After declaring prev and cur, replace dp[ind-1] to prev and dp[ind] with cur and after the inner loop executes, we will set prev = cur, so that the cur row can serve as prev for the next index.

Code:

## C++ Code

``````#include <bits/stdc++.h>

using namespace std;

int lcs(string &s1, string &s2){

int n = s1.size();
int m = s2.size();

vector<int> prev(m+1,0), cur(m+1,0);

int ans = 0;

for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(s1[i-1]==s2[j-1]){
int val = 1 + prev[j-1];
cur[j] = val;
ans = max(ans,val);
}
else
cur[j] = 0;
}
prev=cur;
}

return ans;

}

int main() {

string s1= "abcjklp";
string s2= "acjkp";

cout<<"The Length of Longest Common Substring is "<<lcs(s1,s2);
}
``````

Output:

The Length of Longest Common Substring is 3

Time Complexity: O(N*M)

Reason: There are two nested loops.

Space Complexity: O(M)

Reason: We are using an external array of size ‘M+1’ to store only two rows.

## Java Code

``````import java.util.*;

class TUF{
static int lcs(String s1, String s2){

int n = s1.length();
int m = s2.length();

int prev[]=new int[m+1];
int cur[]=new int[m+1];

int ans = 0;

for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(s1.charAt(i-1)==s2.charAt(j-1)){
int val = 1 + prev[j-1];
cur[j] = val;
ans = Math.max(ans,val);
}
else
cur[j] = 0;
}
prev=cur;
}

return ans;

}

public static void main(String args[]) {

String s1= "abcjklp";
String s2= "acjkp";

System.out.println("The Length of Longest Common Substring is "+lcs(s1,s2));
}
}``````

Output:

The Length of Longest Common Substring is 3

Time Complexity: O(N*M)

Reason: There are two nested loops.

Space Complexity: O(M)

Reason: We are using an external array of size ‘M+1’ to store only two rows.

## Python Code

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

prev = [0 for i in range(m + 1)]
cur = [0 for i in range(m + 1)]

ans = 0

for i in range(1, n + 1):
for j in range(1, m + 1):
if s1[i-1] == s2[j-1]:
val = 1 + prev[j-1]
cur[j] = val
ans = max(ans, val)
else:
cur[j] = 0
prev = cur[:]

return ans

def main():
s1 = "abcjklp"
s2 = "acjkp"

print("The Length of Longest Common Substring is", lcs(s1, s2))

if __name__ == '__main__':
main()
``````

Output:

The Length of Longest Common Substring is 3

Time Complexity: O(N*M)

Reason: There are two nested loops.

Space Complexity: O(M)

Reason: We are using an external array of size ‘M+1’ to store only two rows.