[leetcode-97]Interleaving String（java)

问题描述：
Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

For example,
Given:
s1 = “aabcc”,
s2 = “dbbca”,

When s3 = “aadbbcbcac”, return true.
When s3 = “aadbbbaccc”, return false.

分析：这道题，我觉得是比较难的。我最开始的想法是使用递归，但是觉得递归可能会超时，就利用两个指针吗，齐头并进，当遇到二者相等时，就把中间状态存到栈里面。如果以后走不通了，就出栈，恢复状态。再继续查找，恢复等等，当数据小规模时，可以work，但是数据量一大就TLE。
于是使用二维DP算法（早该想到）。其核心的状态转移方程为：
f(i,j) = s1[i-1][j]==s3[i+j-1] && f[i-1,j] || (s2[i][j-1]==s3[i+j-1] && f[i][j-1])

代码如下：324ms

public class Solution {
        public boolean isInterleave(String s1, String s2, String s3) {
        int row = s1.length();
        int col = s2.length();
        int length = s3.length();
        if(row+col!=length)
            return false;
        if(row==0)
            return s2.equals(s3);
        else if(col==0)
            return s1.equals(s3);

        boolean[][] matrix = new boolean[row+1][col+1];
        matrix[0][0] = true;

        for(int i = 0;i<=row;i++){
            for(int j = 0;j<=col;j++){

                if(i>0){
                    matrix[i][j] = s1.charAt(i-1)==s3.charAt(i+j-1) && matrix[i-1][j];
                }
                if(j>0)
                    matrix[i][j] |= s2.charAt(j-1)==s3.charAt(i+j-1) && matrix[i][j-1];
            }
        }
        return matrix[row][col];
    }
}

代码1：TLE

    class Node{
        int index1;
        int index2;
        int index3;
        public Node(int index1,int index2,int index3){
            this.index1 = index1;
            this.index2 = index2;
            this.index3 = index3;
        }
    }
    public boolean isInterleave2(String s1, String s2, String s3) {
        int s1Len = s1.length();
        int s2Len = s2.length();
        int index1=0,index2=0,index3 = 0;
        Stack<Node> nodes = new Stack<>();

        char[] s1Array = s1.toCharArray();
        char[] s2Array = s2.toCharArray();
        char[] s3Array = s3.toCharArray();

        while(index1<s1Len || index2<s2Len){
            if( (index1>=s1Len || s3Array[index3]!=s1Array[index1]) && (index2>=s2Len ||s3Array[index3] != s2Array[index2])){
                if(nodes.empty())
                    return false;
                Node tmpNode = nodes.pop();
                index1 = tmpNode.index1;
                index2 = tmpNode.index2;
                index3 = tmpNode.index3;
                index2++;index3++;
            }
            else{
                if(index1<s1Len && s3Array[index3]==s1Array[index1]){
                    if(index2<s2Len && s1Array[index1]==s2Array[index2]){
                        Node node = new Node(index1,index2,index3);
                        nodes.push(node);
                    }
                    index1++;
                    index3++;
                }else if(index2<s2Len && s3Array[index3]==s2Array[index2]) {
                    index2++;
                    index3++;
                }else
                    return false;
            }
        }
        return true;
    }

代码2：递归TLE

//使用递归的思想来进行
    public boolean isInterleave(String s1, String s2, String s3) {
        if(s1.length()<=0)
            return s2.equals(s3);
        if(s2.length()<=0)
            return s1.equals(s3);
        if(s3.length()<=0)
            return false;

        if(s1.charAt(0)==s3.charAt(0)&&s2.charAt(0)!=s3.charAt(0))
            return isInterleave(s1.substring(1),s2,s3.substring(1));
        else if(s2.charAt(0)==s3.charAt(0)&&s1.charAt(0)!=s3.charAt(0))
            return isInterleave(s1,s2.substring(1),s3.substring(1));
        else if(s1.charAt(0)==s2.charAt(0)&&s1.charAt(0)==s3.charAt(0)){
            return isInterleave(s1.substring(1),s2,s3.substring(1))||isInterleave(s1,s2.substring(1),s3.substring(1));
        }else
            return false;
    }