[Coding Made Simple] String Interleaving

Given three strings, return true if third string is interleaving of first and second string.

 

By running some examples, it seems that as long as s1.length() + s2.length() == s3.length() and both s1 and s2 are common subsequences of s3, 

s3 is interleaving of s1 and s2. However, this assumption is not correct as shown in the following counter example.

s1 = "aba", s2 = "aca", s3 = "abacaa", both s1 and s2 are common subsequence of s3, but s3 is not interleaving of s1 and s2. The problem lies in 

that s1 and s2 have overlapping characters in the common subsequence portion of s3. 

 

Solution 1. Recursion

Because we need to keep the relative order of characters of s1 and s2 in s3, we know that for the last character of s3 must be either from s1's or s2's 

end if s3 is interleaving of s1 and s2. If this is not the case, we know for sure s3 is not interleaving of s1 and s2.

Based on the above observation, the following recursive formulas are derived. 

Base case: all characters in s3 are checked already, return true.

For s1[0.....i], s2[0....j], s3[0... i + j + 1], 

case 1: there are unused characters in s1, i >= 0 && s1[i] == s3[i + j + 1]

　　     check if s3[0....i + j] is interleaving of s1[0...i - 1] and s2[0....j];

if case 1 is false, proceed to case 2.

case 2: there are unused characters in s2, j >= 0 && s2[j] == s3[i + j + 1]

　　     check if s3[0....i + j] is interleaving of s1[0...i] and s2[0....j - 1];

if case 2 is false, we' just checked all possibilities, so return false.

 

Similarly with a lot of recursive solutions, this solution has the overlapping subproblems issue. 

For example,  for s1[0, 6] and s2[0, 5], we have the following recursive tree. 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　s1[0,6] and s2[0,5]

　　　　　　　　　　　　　　s1[0,5] and s2[0,5]　　　　　　　　　　　　　　　　　　　　s1[0, 6] and s2[0,4]

　　　　s1[0,4] and s2[0, 5]　　　　　　s1[0,5] and s2[0,4]　　　　　　　　　　　s1[0,5] and s2[0,4]　　　　　　s1[0,6] and s2[0,4]

The red subproblems are overlapped.

 

public class InterleavingString {
    public boolean isInterleavingStringRecursion(String s1, String s2, String s3) {
        if(s1.length() + s2.length() != s3.length()) {
            return false;
        }
        return recursiveHelper(s1, s1.length() - 1, s2, s2.length() - 1, s3, s3.length() - 1);
    }
    private boolean recursiveHelper(String s1, int endIdx1, String s2, int endIdx2, String s3, int endIdx3) {
        if(endIdx3 < 0) {
            return true;
        }
        if(endIdx1 >= 0 && s1.charAt(endIdx1) == s3.charAt(endIdx3)) {
            if(recursiveHelper(s1, endIdx1 - 1, s2, endIdx2, s3, endIdx3 - 1)) {
                return true;
            }
        }
        else if(endIdx2 >= 0 && s2.charAt(endIdx2) == s3.charAt(endIdx3)) {
            if(recursiveHelper(s1, endIdx1, s2, endIdx2 - 1, s3, endIdx3 - 1)) {
                return true;
            }            
        }
        return false;
    }
    public static void main(String[] args) {
        String s1 = "aab", s2 = "axy", s3 = "aaxaby", s4 = "abaaxy";
        String s5 = "aabcc", s6 = "dbbca", s7 = "aadbbcbcac", s8 = "aadbbbaccc";
        InterleavingString test = new InterleavingString();
        System.out.println(test.isInterleavingStringRecursion(s1, s2, s3));
        System.out.println(test.isInterleavingStringRecursion(s1, s2, s4));
        System.out.println(test.isInterleavingStringRecursion(s5, s6, s7));
        System.out.println(test.isInterleavingStringRecursion(s5, s6, s8));        
    }
}

 

 

Solution 2. Dynamic Programming 

State: T[i][j]: whether s3[0 ~ i + j - 1] is interleaving of s1[0 ~ i - 1] and s2[0 ~ j - 1]

Function: same with the recursive solution.

Init: T[0][0] = true, as an empty string is interleaving of two empty strings　

 

public boolean isInterleavingStringDp(String s1, String s2, String s3) {
    if(s1.length() + s2.length() != s3.length()) {
        return false;
    }
    boolean[][] T = new boolean[s1.length() + 1][s2.length() + 1];
    T[0][0] = true;
    for(int i = 1; i < T.length; i++) {
        T[i][0] = s1.charAt(i - 1) == s3.charAt(i - 1) && T[i - 1][0];
    }
    for(int j = 1; j < T[0].length; j++) {
        T[0][j] = s2.charAt(j - 1) == s3.charAt(j - 1) && T[0][j - 1];
    }
    for(int i = 1; i < T.length; i++) {
        for(int j = 1; j < T[0].length; j++) {
            if(s1.charAt(i - 1) == s3.charAt(i + j - 1) && T[i - 1][j]) {
                T[i][j] = true;
            }
            else if(s2.charAt(j - 1) == s3.charAt(i + j - 1) && T[i][j - 1]) {
                T[i][j] = true;
            }
            else {
                T[i][j] = false;
            }
        }
    }
    return T[s1.length()][s2.length()];
}

 

 

Related Problems 

Distinct Subsequence