leetcode97. 交错字符串

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/interleaving-string

题目描述

给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错组成的。
两个字符串 s 和 t 交错的定义与过程如下，其中每个字符串都会被分割成若干非空子字符串：
s = s1 + s2 + … + sn
t = t1 + t2 + … + tm
|n - m| <= 1
交错是 s1 + t1 + s2 + t2 + s3 + t3 + … 或者 t1 + s1 + t2 + s2 + t3 + s3 + …
注意：a + b 意味着字符串 a 和 b 连接。

示例：

输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出：true

示例 2：
输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出：false

示例 3：
输入：s1 = “”, s2 = “”, s3 = “”
输出：true

提示：
0 <= s1.length, s2.length <= 100
0 <= s3.length <= 200
s1、s2、和 s3 都由小写英文字母组成

解题思路

首先介绍经典的动态规划的方法。写出来后，再演示空间压缩的方法
s1和上 s2 的长度分别定为 M 和 N。
s3 是由 s1 和 s2 组成的，长度必然是 M +N 不等返回false.
然后生成大小是dp[M + 1][n + 1] 的布尔类型二维数组。
dp[i][j] 代表str1(0 , i - 1) 和 s2 (0,j - 1)能否交错组成s3(0,i + j - 1).
最后返回dp[M][N] 也就是最后的值，
1.两个都是空串时，dp[0][0] = true.都是空没啥说的了，
2.一个为null 一个不是时，s3 和非null 得保持一直，才是true.
3,一般位置上，分为两种情况，
当前字符和 s1 相等 dp[i - 1][j]
当前字符和 s2 相等，dp[i][j - 1].
两种情况满足一种就是true，否则是false.

代码演示：

 /**
     * 交替字符串 动态规划
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public boolean isInterleave(String s1, String s2, String s3) {
        char[] ch1 = s1.toCharArray();
        char[] ch2 = s2.toCharArray();
        char[] aim = s3.toCharArray();
        if (ch2.length + ch1.length != aim.length){
            return false;
        }
        //记录每个位置上是否
        boolean[][] dp = new boolean[ch1.length + 1][ch2.length + 1];
        //0 位置
        dp[0][0] = true;
        //初始化第一行
        for (int i = 1; i <= ch1.length;i++){
            if (ch1[i- 1]  != aim[i - 1]){
                break;
            }
            dp[i][0] = true;
        }
        //初始化第一列
        for (int j = 1;j <= ch2.length;j++){
            if (ch2[j - 1] != aim[j - 1]){
                break;
            }
            dp[0][j] = true;
        }
        //一般位置
        for (int i = 1; i <= ch1.length;i++){
            for (int j = 1;j <= ch2.length;j++){
                //aim 所在位置 i + j - 1;
                //和s1 相等时
                boolean p1 = (ch1[i - 1] == aim[i + j - 1]) && dp[i - 1][j];
                //和s2 相等时
                boolean p2 = (ch2[j - 1] == aim[i + j - 1]) && dp[i][j - 1];
                dp[i][j] = p1 || p2;
            }
        }
        return dp[ch1.length][ch2.length];
    }

动态规划加状态压缩

dp[i][j] 依赖 dp[i - 1][j ] 和 dp[i ][j - 1 ] 两个位置，相邻位置，所以可以把二维数组压缩成一维数组，从左向右，上到下滚动更新，
如图演示：

五角星位置依赖两个三角位置，所以这种事可以使用状态压缩得。

代码演示

 /**
     * 动态规划  状态压缩
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public boolean isInterleave1(String s1, String s2, String s3) {
        char[] ch1 = s1.toCharArray();
        char[] ch2 = s2.toCharArray();
        char[] aim = s3.toCharArray();
        if (ch2.length + ch1.length != aim.length){
            return false;
        }
        //记录每个位置上是否
        boolean[] dp = new boolean[ch2.length + 1];
        dp[0] = true;

        //初始化下一行
        for (int j = 1;j <= ch2.length;j++){
            if (ch2[j - 1] != aim[j - 1]){
                break;
            }
            dp[j] = true;
        }

        for (int i = 1; i <= ch1.length;i++){
            //滚动更新下一行最左边得值
            dp[0] = dp[0] && ch1[i - 1] == aim[i - 1];
            for (int j = 1;j <= ch2.length;j++){
                //aim 的长度 i + j - 1;
                boolean p1 = (ch1[i - 1] == aim[i + j - 1]) && dp[j];
                boolean p2 = (ch2[j - 1] == aim[i + j - 1]) && dp[j - 1];
                if (p1 || p2){
                    dp[j] = true;
                }else{
                    dp[j] = false;
                }
            }
        }
        return dp[ch2.length];
    }