LeetCode 97（Interleaving String）Java

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

给定3个字符串，判断s3是否可以由s1和s2交错组成；

例如：s1="aa"，s2="bc"，s3="abca"；s3可以由s1和s2交错组成；

思路：很多字符串问题某一位置的解会与它上一位置的解有关，这种情况我们首先可以想到递归，将问题规模缩小。

因为这个递归明显有很多重复的状态，为避免重复计算，考虑动态规划，构建动态规划表和状态转移方程：

boolean[][] dp=new boolean[s1.length()+1][s2.length()+1]；

其中第0行代表仅用s1中元素能否组成s3，第0列代表仅用s2中元素能否组成s3，dp[0][0]=true；

dp[i][j]代表s3的前 i+j 个字符能否由s1的前 i 个字符和s2的前 j 个字符交错组成：该位置的值取决于：

1. 若s3的第i+j-1个字符等于s1的第i-1个字符，那么s3能否由s1和s2交错组成，取决为s3的前i+j-1个字符由s1的前i-1个字符和s2的前j个字符能否交错组成；

2.若s3的第i+j-1个字符等于s2的第 j-1个字符，那么s3能否由s1和s2交错组成，取决为s3的前i+j-1个字符由s1的前i个字符和s2的前j-1个字符能否交错组成；

3.若s3的第i+j-1个字符等于s1的第i-1个字符，又等于s2的第 j-1个字符 。取上述两者的并；

4.若均不相等，dp[i][j]=false;

所以该问题的时间复杂度为O（s1.length()*s2.length()）；空间复杂度为O（s1.length()*s2.length()）；

由于每次的状态转移方程只与dp矩阵左边元素和上边元素有关，我们可以将dp矩阵用dp数组代替；

空间复杂度降为O（min( s1.length() , s2.length() )）；

思路是滚动这个数组，用当前行的值覆盖上一行的值；这种方法仅能在不用返回路径的情况下使用，覆盖了之前值就丢失了路径的信息；

代码：

/*
Author:Jassy
Time:2016/11/30
Number:LeetCode 97(Interleaving String)
Resource:https://leetcode.com/problems/interleaving-string/
Result:AC
Conclusion:
*/
public class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        if(s1.length()+s2.length()!=s3.length()){
            return false;
        }
        int length1=s1.length();
        int length2=s2.length();
        String s=length1>=length2?s2:s1;
        String l=s1==s?s2:s1;
        boolean[] dp=new boolean[s.length()+1];
        dp[0]=true;
        for(int i=1;i<dp.length;i++){
            dp[i]=(s.charAt(i-1)==s3.charAt(i-1));
        }
        for(int i=1;i<=l.length();i++){
            if(l.charAt(i-1)!=s3.charAt(i-1)){
                dp[0]=false;
            }
            for(int j=1;j<dp.length;j++){
                if(s3.charAt(i+j-1)==l.charAt(i-1) && s3.charAt(i+j-1)==s.charAt(j-1)){
                    dp[j]=dp[j-1] || dp[j];
                }else if(s3.charAt(i+j-1)==l.charAt(i-1) && s3.charAt(i+j-1)!=s.charAt(j-1)){
                    
                }else if(s3.charAt(i+j-1)==s.charAt(j-1) && s3.charAt(i+j-1)!=l.charAt(i-1)){
                    dp[j]=dp[j-1];
                }else{
                    dp[j]=false;
                }
            }
        }
        return dp[dp.length-1];
    }
}