判断是否是交叉字符串

描述

给出三个字符串:s1、s2、s3，判断s3是否由s1和s2交叉构成。

样例

比如 s1 = "aabcc" s2 = "dbbca"

    - 当 s3 = "aadbbcbcac"，返回  true.

    - 当 s3 = "aadbbbaccc"， 返回 false.

挑战

要求时间复杂度为O(n^2)或者更好

思路，遍历s3和s1、s2对比，判断s3当前下标index3对应字符c3是否和s1或s2对应的字符相同，中途发现s3的字符和s1和s2都不相同则说明不是交叉字符串，则终止遍历，如果遍历完毕则说明是交叉字符串。我这种方法比动态规划(dynamic programming)的时间和空间复杂读都低。

如果s1下标index1的字符c1及s2下标index2的字符c2都和c3相同时我们不知道c3是对应c1还是c2，我们就可以用试的方法，假设c3是和c1对应那么就s1小标加1递归调用继续遍历，假设c3是和c2对应就s2小标加1递归调用继续遍历，只要有一种情能继续遍历完就是交叉字符串。如过c3只和c1相同那么index1加1继续遍历s3，如果c3只和c2相同则index2加1继续遍历s3,

public class Solution {
    /**
     * @param s1: A string
     * @param s2: A string
     * @param s3: A string
     * @return: Determine whether s3 is formed by interleaving of s1 and s2
     */
    public boolean isInterleave(String s1, String s2, String s3) {
        if(s1 == null || s2 == null || s3 == null) {
			return false;
		}
		if(s1.length() + s2.length() < s3.length()) {
			return false;
		}
		
		return isInterleave(new StringBuilder(s1),new StringBuilder(s2),
				new StringBuilder(s3), 0, 0, 0);
    }
    
    public boolean isInterleave(StringBuilder s1, StringBuilder s2, StringBuilder s3, int index1, int index2, int index3) {
		for (int i = index3; i < s3.length(); i++) {
			char c = s3.charAt(i);
			if(index1 < s1.length() && c == s1.charAt(index1) && index2 < s2.length() && c == s2.charAt(index2)) {
				return isInterleave(s1, s2, s3, index1+1, index2, i+1) || isInterleave(s1, s2, s3, index1, index2+1, i+1);
			} else if(index1 < s1.length() && c == s1.charAt(index1)) {
				++index1;
			} else if(index2 < s2.length() && c == s2.charAt(index2)){
				++index2;
			} else {
				return false;
			}
		}
		return true;
    }
}

别人写的动态规划的方法

https://blog.youkuaiyun.com/aphysia/article/details/77941271

public class Solution {
    /**
     * Determine whether s3 is formed by interleaving of s1 and s2.
     * @param s1, s2, s3: As description.
     * @return: true or false.
     */
    public boolean isInterleave(String s1, String s2, String s3) {
        if(null == s1 || null == s2 || null == s3 || s1.length() + s2.length() != s3.length())
            return false;
        if(s1.length() <= 0 && s2.length() <= 0 && s3.length() <= 0)
            return true;

        boolean[][] common = new boolean[s1.length() + 1][s2.length() + 1];
        for(int i = 1;i <= s1.length();i++)
        {
            if(s1.charAt(i - 1) == s3.charAt(i - 1))
            {
                common[i][0] = true;
            }
        }

        for(int i = 1;i <= s2.length();i++)
        {
            if(s2.charAt(i - 1) == s3.charAt(i - 1))
            {
                common[0][i] = true;
            }
        }

        for(int i = 1;i <= s1.length();i++)
        {
            for(int j = 1;j <= s2.length();j++)
            {
                if(s1.charAt(i - 1) == s3.charAt(i + j - 1))
                {
                    common[i][j] = common[i - 1][j];
                }

                if(common[i][j])
                {
                    continue;
                }

                if(s2.charAt(j - 1) == s3.charAt(i + j - 1))
                {
                    common[i][j] = common[i][j - 1];
                }
            }
        }
        return common[s1.length()][s2.length()];
    }
}