【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划

这篇具有很好参考价值的文章主要介绍了【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】

🚀 算法题 🚀

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，CSDN-Java领域优质创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚀 算法题 🚀

【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】

🚩 题目链接

97. 交错字符串

⛲ 题目描述

给定三个字符串 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 连接。

示例 1：
【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】

输入：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字符串中找出一个互相交错的字符串，等于s3，如果存在，返回true，如果不存在，返回false。
这个题目和我们前面讲过的【LeetCode: 115. 不同的子序列 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】，核心求解思路是一样的，此处就不做过多的讲解，不会的同学可以先去看一下之前的文章，然后再来学习这道题目就会更加容易了。
有了基本的思路，接下来我们就来通过代码来实现一下。

🥦 实现代码

class Solution {

    char[] arr1,arr2,arr3;
    String s1,s2,s3;

    public boolean isInterleave(String s1, String s2, String s3) {
        this.s1=s1;
        this.s2=s2;
        this.s3=s3;
        arr1=s1.toCharArray();
        arr2=s2.toCharArray();
        arr3=s3.toCharArray();
        return process(0,0,0);
    }

    public boolean process(int i,int j,int k){
        if(k>=arr3.length) return i>=arr1.length&&j>=arr2.length;
        if(i>=arr1.length) return s2.substring(j).equals(s3.substring(k));
        if(j>=arr2.length) return s1.substring(i).equals(s3.substring(k));
        boolean ans=false;
        if(arr1[i]==arr3[k]){
            ans|=process(i+1,j,k+1);
        }
        if(arr2[j]==arr3[k]){
            ans|=process(i,j+1,k+1);
        }
        return ans;
    }
}

🥦 运行结果

超时了，可以接受，是我们期待的结果。

【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】

⚡ 记忆化搜索

🥦 求解思路

因为在递归的过程中，会重复的出现一些多次计算的结果，我们通过开辟一个数组，将结果提前缓存下来，算过的直接返回，避免重复计算，通过空间来去换我们的时间。

🥦 实现代码

class Solution {

    char[] arr1,arr2,arr3;
    String s1,s2,s3;
    int[][][] dp;

    public boolean isInterleave(String s1, String s2, String s3) {
        this.s1=s1;
        this.s2=s2;
        this.s3=s3;
        arr1=s1.toCharArray();
        arr2=s2.toCharArray();
        arr3=s3.toCharArray();
        int m=arr1.length,n=arr2.length,q=arr3.length;
        dp=new int[m][n][q];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                Arrays.fill(dp[i][j],-1);
            }
        }
        return process(0,0,0);
    }

    public boolean process(int i,int j,int k){
        if(k>=arr3.length) return i>=arr1.length&&j>=arr2.length;
        if(i>=arr1.length) return s2.substring(j).equals(s3.substring(k));
        if(j>=arr2.length) return s1.substring(i).equals(s3.substring(k));
        if(dp[i][j][k]!=-1) return dp[i][j][k]==1;
        boolean ans=false;
        if(arr1[i]==arr3[k]){
            ans|=process(i+1,j,k+1);
        }
        if(arr2[j]==arr3[k]){
            ans|=process(i,j+1,k+1);
        }
        dp[i][j][k]=ans?1:0;
        return ans;
    }
}

🥦 运行结果

通过缓存，将重复计算的结果缓存下来，通过。
【LeetCode: 97. 交错字符串 | 暴力递归=＞记忆化搜索=＞动态规划 | 位置对应】

⚡ 动态规划

🥦 求解思路

有了递归，有了记忆化搜索，接下来就是动态规划了，直接上手。

🥦 实现代码

class Solution {

    char[] arr1,arr2,arr3;
    String s1,s2,s3;
    boolean[][][] dp;

    public boolean isInterleave(String s1, String s2, String s3) {
        this.s1=s1;
        this.s2=s2;
        this.s3=s3;
        arr1=s1.toCharArray();
        arr2=s2.toCharArray();
        arr3=s3.toCharArray();
        int m=arr1.length,n=arr2.length,q=arr3.length;
        dp=new boolean[m+1][n+1][q+1];
        dp[m][n][q]=true;
        for(int j=0;j<=n;j++){
            for(int k=0;k<=q;k++){
                if(s2.substring(j).equals(s3.substring(k))){
                    dp[m][j][k]=true;
                }
            }
        }
        for(int i=0;i<=m;i++){
            for(int k=0;k<=q;k++){
                if(s1.substring(i).equals(s3.substring(k))){
                    dp[i][n][k]=true;
                }
            }
        }
        for(int i=m-1;i>=0;i--){
            for(int j=n-1;j>=0;j--){
                for(int k=q-1;k>=0;k--){
                    boolean ans=false;
                    if(arr1[i]==arr3[k]){
                        ans|=dp[i+1][j][k+1];
                    }
                    if(arr2[j]==arr3[k]){
                        ans|=dp[i][j+1][k+1];
                    }
                    dp[i][j][k]=ans;
                }
            }
        }
        return dp[0][0][0];
    }

}