【LeetCode热题100】打卡第6天:正则表达式匹配

文章目录

  • 正则表达式匹配
    • ⛅前言
    • 题目
    • 题解

正则表达式匹配

⛅前言

大家好,我是知识汲取者,欢迎来到我的LeetCode热题100刷题专栏!

精选 100 道力扣(LeetCode)上最热门的题目,适合初识算法与数据结构的新手和想要在短时间内高效提升的人,熟练掌握这 100 道题,你就已经具备了在代码世界通行的基本能力。在此专栏中,我们将会涵盖各种类型的算法题目,包括但不限于数组、链表、树、字典树、图、排序、搜索、动态规划等等,并会提供详细的解题思路以及Java代码实现。如果你也想刷题,不断提升自己,就请加入我们吧!QQ群号:827302436。我们共同监督打卡,一起学习,一起进步。

博客主页:知识汲取者的博客

LeetCode热题100专栏:LeetCode热题100

Gitee地址:知识汲取者 (aghp) - Gitee.com

Github地址:Chinafrfq · GitHub

题目来源:LeetCode 热题 100 - 学习计划 - 力扣(LeetCode)全球极客挚爱的技术成长平台

PS:作者水平有限,如有错误或描述不当的地方,恳请及时告诉作者,作者将不胜感激

题目

原题链接:10. 正则表达式匹配 - 力扣(LeetCode)

【LeetCode热题100】打卡第6天:正则表达式匹配_第1张图片

题解

  • 解法一:正则表达式

    这里标记是困难,但是如果使用正则表达式一行代码就解决了,但是这题的作者可能并不是想要我们使用正则表达式,而是使用动态规划,如果使用动态规划这题难度直接上升几个等级。所以大家不要为了做题而做题,而是去学习了解更多的算法思路,有时候我们不需要去把一个题给AC了,而是要做到,看到一个题能够第一时间直到这题考察的内容,应该使用哪种算法策略,毕竟现在AI这么流行,直接把一个题交给AI,他立马能够给你解答。

    当然这题使用正则也不赖,也是一种比较优秀的解法,但是却无法锻炼到我们的逻辑思维,因为太简单了正则表达式YYDS

    import java.util.regex.Pattern;
    
    class Solution {
        public boolean isMatch(String s, String p) {
            return Pattern.matches(p, s);
        }
    }
    

    复杂度分析:

    • 时间复杂度: O ( n ) O(n) O(n),正则匹配本质是
    • 空间复杂度: O ( 1 ) O(1) O(1)

    其中 n n n 为字符串的长度

  • 解法二:动态规划

    本段代码来自这位大佬的:fomalhaut1998 - 力扣(LeetCode)

    class Solution {
        public boolean isMatch(String s, String p) {
            /*
            dp五部曲:
            设主串s的长度为m,设模式串p的长度为n;其中s只有小写字母,p有字母/./*
            1.状态定义:dp[i][j]为考虑s[0,i-1]与p[0,j-1]是否能匹配上,能匹配上就为true
            2.状态转移:若要求dp[i][j]就必须考虑到s[i-1]与p[j-1]
                2.1 当p[j-1]不是'*'时
                    2.1.1 若s[i-1]==p[j-1]时,即p[j-1]为'a'-'z'且与s[i-1]相等,看dp[i-1][j-1]
                    2.1.2 p[j-1] == '.'时,直接将'.'变成s[i-1],看dp[i-1][j-1]
                    注意:这里的'.'是匹配一个字符,而不是一连串,如"a.b"->"axb"
                2.2 当p[j-1]是'*'时,主要看p[j-2]做判断
                    2.2.1 p[j-2]为'a'-'z'并且p[j-2]==s[i-1],那么此时s继续往前看,p暂时不动
                        即:看dp[i-1][j]
                    2.2.2 p[j-2]为'.',那么".*"可以变为"....."可以匹配s[i-1]前面的任何字符(万能串)
                        因此,直接看dp[i-1][j](或者直接返回true)
                    2.2.3 剩下的就是p[j-2]为'a'-'z'且p[j-2]!=s[i-1],那么此时p的"x*"作废,看dp[i][j-2]
                这里:2.1.1与2.2.2可以看成一种情形:即s与p均前移一位
                    2.2.1与2.2.2可以看成一种情形:即p不动s前移一位
            3.初始化:
                3.1 空的s
                    3.1.1 空的p,空的s可以匹配空的p,因此dp[0][0]=true
                    3.1.2 非空的p,空的s可能可以匹配非空的p,例如"a*",因此需要经过转移计算
                3.2 空的p
                    3.2.1 空的s,同3.1.1
                    3.2.2 非空的s,空的p不可能匹配非空的s,因此dp[i][0]=false,i∈[1,m]
                3.3 非空的s与非空的p:需要经过转移计算
                其中:3.1.1与3.2.2可以合并为dp[i][0]=i==0
            4.遍历顺序:显然是正序遍历
            5.返回形式:返回dp[m][n]就是考虑s[0,m-1]与p[0,n-1]是否能匹配上
            */
            int m = s.length(), n = p.length();
            boolean[][] dp = new boolean[m + 1][n + 1];
            // 初始化dp[i][0]
            // for(int i = 0; i <= m; i++) {
            //     dp[i][0] = i == 0;
            // }
            dp[0][0] = true;
            // i从0开始
            for(int i = 0; i <= m; i++) {
                // 注意j从1开始
                for(int j = 1; j <= n; j++) {
                    if(p.charAt(j - 1) != '*') {
                        // 1.当p[j-1]不是'*'时(注意j已经从1开始了)
                        // 这里要注意运算优先级问题(加括号)
                        if(i >= 1 && (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '.')) {
                            // s与p均前移一位
                            dp[i][j] = dp[i - 1][j - 1];
                        }
                    } else {
                        // 2.当p[j-1]是'*'时,主要看p[j-2]做判断
                        if(j >= 2 && i >= 1 && 
                        (p.charAt(j - 2) == s.charAt(i - 1) || p.charAt(j - 2) == '.')) {
                            // 看"x*":p不动s前移一位
                            dp[i][j] = dp[i - 1][j];
                        }
                        // 不看"x*":
                        // 剩下的为p[j-2]为'a'-'z'且p[j-2]!=s[i-1],那么此时p的"x*"作废,看dp[i][j-2]
                        if(j >= 2) {
                            dp[i][j] |= dp[i][j - 2];
                        }
                        // 这里的|=表示只要满足了其中一个条件就可以使得dp[i][j]==true
                        // 通俗一点的解释就是:当p[j-1]=='*'时,
                        // 若p[j-2]==s[i-1]||p[j-2]=='.',则dp[i][j]可以继承dp[i-1][j]:转移路径1
                        // 若p[j-2]!=s[i-1],则dp[i][j]可以继承dp[i][j-2]:转移路径2
                        // 满足任意一条转移路径就可以使得dp[i][j]=true
                    }        
                }
            }
            // 所求即为考虑s[0,m-1]与p[0,n-1]是否能匹配上
            return dp[m][n];
        }
    }
    

    详情参考官方代码

    复杂度分析:

    • 时间复杂度: O ( n ∗ m ) O(n*m) O(nm)
    • 空间复杂度: O ( n ∗ m ) O(n*m) O(nm)

    其中 n n n 为数组中元素的个数

你可能感兴趣的:(#,LeetCode热题100,编程练习,leetcode,正则表达式,算法)