[Coding Made Simple] Longest Common Substring

Given two strings, find longest common substring between them.

 

Solution 1. Brute force search, O(n^2 * m), O(1) memory

Algorithm.

O(n^2) runtime to find all substrings from string A. For each substring, it takes O(m) time to check if it exists in string B.

public class Solution {
    public int longestCommonSubstring(String A, String B) {
        if(A == null || B == null || A.length() == 0 || B.length() == 0){
            return 0;
        }
        int max = Integer.MIN_VALUE;
        for(int i = 0; i < A.length(); i++){
            for(int j = i + 1; j <= A.length(); j++){
                if(B.indexOf(A.substring(i, j)) >= 0){
                    max = Math.max(max, j - i);                    
                }
                else{
                    break;
                }
            }
        }
        return max;
    }
}

 

Solution 2. Dynamic Programming, O(n * m) runtime, O(n * m) space

Solution 1 is not efficient in that each time a substring is checked, it always start from index 0 of string B. The previous check

result of smaller substrings are not used at all. For example, if A[i...j] is a substring in B, then in order to check if A[i...j + 1] is 

a substring of B or not, we just need to check if the next character of substring A[i...j] in B equals to A[j + 1] or not. This only takes

O(1) time. But in solution 1 there is no memorization of previous results, so it takes O(m) time for each check.

 

State:

lcs[i][j]:  the length of the common substring that ends at A[i - 1] and B[j - 1].

Function:

lcs[i][j] = 1 + lcs[i - 1][j - 1],  if A[i - 1] == B[j - 1];

lcs[i][j] = 0, if A[i - 1] != B[j - 1];

Initialization:

lcs[i][0] = 0; lcs[0][j] = 0;

Answer:

max value of lcs[i][j]

public class Solution {
    public int longestCommonSubstring(String A, String B) {
        if(A == null || B == null || A.length() == 0 || B.length() == 0){
            return 0;
        }    
        int n = A.length();
        int m = B.length();
        int[][] lcs = new int[n + 1][m + 1];
        for(int i = 0; i <= n; i++){
            lcs[i][0] = 0;
        }
        for(int j = 0; j <= m; j++){
            lcs[0][j] = 0;
        }
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                if(A.charAt(i - 1) == B.charAt(j - 1)){
                    lcs[i][j] = lcs[i - 1][j - 1] + 1;    
                }
                else{
                    lcs[i][j] = 0;
                }
            }
        }
        int max = Integer.MIN_VALUE;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                max = Math.max(max, lcs[i][j]);
            }
        }
        return max;
    }
}

 

Follow up question: Find one longest common substring.

Answer: find the max value in lcs[i][j]; then go diagonal top left one grid at a time, until the value of the grid is 0.

 

Related Problems

Longest Common Subsequence