剑指offer 19 正则表达式匹配

最新推荐文章于 2020-11-17 22:04:48 发布
最新推荐文章于 2020-11-17 22:04:48 发布
阅读量179 收藏
点赞数
分类专栏： 八股编程 文章标签： 字符串 算法 动态规划 递归 正则表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_bian/article/details/108096267
版权 
@date: 8/18/2020 10:26:00 AM
@难度: 困难
考察内容： 字符串 动态规划
@e-mail: lwyz521604#163.com
题目来自《剑指offer》 电子工业出版社

请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但与"aa.a"和"ab*a"均不匹配。

示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。

示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。

示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
  • s 可能为空，且只包含从 a-z 的小写字母。
  • p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 ，无连续的 '’。

递归解法

从示例来看，题目中的.*指的应该是任意的字符串，而不是只含有相同字符的字符串。这道题可以通过逐个判断模式字符串中前两个字符的情况，然后递归地来解:

class Solution {
    public boolean isMatch(String s, String p) {

        return this.arrayMatch(s.toCharArray(), p.toCharArray(), 0, 0);
    }

    private boolean arrayMatch(char[] arrS, char[] arrP, int ptrS, int ptrP){
        int n1 = arrS.length;
        int n2 = arrP.length;

        if(ptrP==n2){  // 模式为空时，字符串必须为空
            return n1 == ptrS;
        }

        if(n1-ptrS==0){  // 字符串为空，模式非空时，模式必须是 某* 的形式
            if(n2-ptrP>=2 && arrP[ptrP+1]=='*'){
                return arrayMatch(arrS, arrP, ptrS, ptrP+2);
            }
            return false;
        }

        // 如果模式字符串只剩最后一个位置
        if(n2-ptrP==1){
            if(n1-ptrS==1){
                if(arrP[ptrP]=='.')
                    return true;
                else
                    return arrP[ptrP]==arrS[ptrS];
            }
            return false;
        }

        // 模式字符串还剩下两位或超过两位的情况
        if(arrP[ptrP]=='.'){
            if(arrP[ptrP+1]=='*'){
                // 题目对这种情况的意思似乎是任意的字符出现任意次
                return arrayMatch(arrS, arrP, ptrS+1, ptrP+2)
                        || arrayMatch(arrS, arrP, ptrS, ptrP+2)
                        || arrayMatch(arrS, arrP, ptrS+1, ptrP);
            }else{
                return arrayMatch(arrS, arrP, ptrS+1, ptrP+1);
            }
        }else{
            if(arrP[ptrP+1]=='*'){
                if(arrS[ptrS]==arrP[ptrP]){
                    return arrayMatch(arrS, arrP, ptrS+1, ptrP+2)
                            || arrayMatch(arrS, arrP, ptrS, ptrP+2)
                            || arrayMatch(arrS, arrP, ptrS+1, ptrP);
                }else{
                    return arrayMatch(arrS, arrP, ptrS, ptrP+2);
                }
            }else{
                if(arrS[ptrS]==arrP[ptrP]){
                    return arrayMatch(arrS, arrP, ptrS+1, ptrP+1);
                }else{
                    return false;
                }
            }
        }

    }
}

提交结果如下所示，时间效率并不高，原因应该是在递归调用中的几个“或”语句下面存在重复求解子问题的情况，因此可以用一个矩阵将这些子问题的求解结果存储下来，这样也就是动态规划方法了。

执行用时：846 ms, 在所有 Java 提交中击败了5.03%的用户
内存消耗：38.3 MB, 在所有 Java 提交中击败了59.69%的用户

自上而下的动态规划解法

前面已经提到，递归解法存在重复求解子问题的情况，因而可以在递归过程中增加备忘机制，使得时间效率大幅提高。《算法导论》中称这种思路为自上而下带备忘的动态规划方法。其具体实现如下，由于直接在上一个版本的基础上略加修改而成的，代码的书写不太优美，其实可以让arrayMatch函数变成void的。

class Solution {
    public boolean isMatch(String s, String p) {

        int[][] count = new int[s.length()+1][p.length()+1];
        return this.arrayMatch(s.toCharArray(), p.toCharArray(), 0, 0, count);

    }

    private boolean arrayMatch(char[] arrS, char[] arrP, int ptrS, int ptrP, int[][] count){
        int n1 = arrS.length;
        int n2 = arrP.length;

        if(count[ptrS][ptrP]==1)
            return true;
        if(count[ptrS][ptrP]==-1)
            return false;

        if(ptrP==n2){  // 模式为空时，字符串必须为空
            if(n1 == ptrS){
                count[ptrS][ptrP] = 1;
                return true;
            }
            count[ptrS][ptrP] = -1;
            return false;
        }

        if(n1-ptrS==0){  // 字符串为空，模式非空时，模式必须是 某* 的形式
            if(n2-ptrP>=2 && arrP[ptrP+1]=='*'){
                boolean temp = arrayMatch(arrS, arrP, ptrS, ptrP+2, count);
                if(temp)
                    count[ptrS][ptrP] = 1;
                else
                    count[ptrS][ptrP] = -1;
                return temp;
            }
            count[ptrS][ptrP] = -1;
            return false;
        }

        // 如果模式字符串只剩最后一个位置
        if(n2-ptrP==1){
            if(n1-ptrS==1){
                if(arrP[ptrP]=='.') {
                    count[ptrS][ptrP] = 1;
                    return true;
                }else{
                    if(arrP[ptrP]==arrS[ptrS]){
                        count[ptrS][ptrP] = 1;
                        return true;
                    }
                    count[ptrS][ptrP] = -1;
                    return false;
                }
            }
            count[ptrS][ptrP] = -1;
            return false;
        }

        // 模式字符串还剩下两位或超过两位的情况
        if(arrP[ptrP]=='.'){
            if(arrP[ptrP+1]=='*'){
                // 题目对这种情况的意思似乎是任意的字符出现任意次
                boolean temp = arrayMatch(arrS, arrP, ptrS+1, ptrP+2, count)
                        || arrayMatch(arrS, arrP, ptrS, ptrP+2, count)
                        || arrayMatch(arrS, arrP, ptrS+1, ptrP, count);
                if(temp)
                    count[ptrS][ptrP] = 1;
                else
                    count[ptrS][ptrP] = -1;
                return temp;
            }else{
                boolean temp = arrayMatch(arrS, arrP, ptrS+1, ptrP+1, count);
                if(temp)
                    count[ptrS][ptrP] = 1;
                else
                    count[ptrS][ptrP] = -1;
                return temp;
            }
        }else{
            if(arrP[ptrP+1]=='*'){
                if(arrS[ptrS]==arrP[ptrP]){
                    boolean temp = this.arrayMatch(arrS, arrP, ptrS+1, ptrP+2, count)
                            || this.arrayMatch(arrS, arrP, ptrS, ptrP+2, count)
                            || this.arrayMatch(arrS, arrP, ptrS+1, ptrP, count);
                    if(temp)
                        count[ptrS][ptrP] = 1;
                    else
                        count[ptrS][ptrP] = -1;
                    return temp;
                }else{
                    boolean temp = arrayMatch(arrS, arrP, ptrS, ptrP+2, count);
                    if(temp)
                        count[ptrS][ptrP] = 1;
                    else
                        count[ptrS][ptrP] = -1;
                    return temp;
                }
            }else{
                if(arrS[ptrS]==arrP[ptrP]){
                    boolean temp = arrayMatch(arrS, arrP, ptrS+1, ptrP+1, count);
                    if(temp)
                        count[ptrS][ptrP] = 1;
                    else
                        count[ptrS][ptrP] = -1;
                    return temp;
                }else{
                    count[ptrS][ptrP] = -1;
                    return false;
                }
            }
        }

    }

}

在系统中提交的结果为

执行用时：2 ms, 在所有 Java 提交中击败了99.91%的用户
内存消耗：39.7 MB, 在所有 Java 提交中击败了20.39%的用户
麦克斯韦的妖精
关注
专栏目录
剑指offer | 19. 正则表达式匹配
Leonadoice的博客
12-06 123
题目内容： 请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。 示例 1: 输入: s = "aa" p = "a" 输出: false 解释: "a" 无法匹配 "aa" 整个字符串。 示例 2: 输入: s = "aa" p = "a*" 输出: true 解释:
剑指offer-正则表达式匹配
Keep Learning
04-07 1804
题目描述 请实现一个函数用来匹配包括’.’和’‘的正则表达式。模式中的字符’.’表示任意一个字符，而’‘表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串”aaa”与模式”a.a”和”ab*ac*a”匹配，但是与”aa.a”和”ab*a”均不匹配 地址： 牛客链接 问题分析 这题的难点在于如何处理 * 的情况 先从递归尝试，递...
剑指Offer19_正则表达式匹配
qitong啊的博客
07-24 588
19 正则表达式匹配未完成√ 难题 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bhvr72kY-1595564394672)(剑指offer题解.assets/正则.png)] public class 剑指Offer_19_正则表达式匹配 { public boolean isMatch(String s, String p) { //动态规划 画图!!!和最小编辑距离类似 int sl = s.length();
《剑指offer》—— 19. 正则表达式匹配
dss875914213的博客
08-15 146
难度：困难 题目 请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但与"aa.a"和"ab*a"均不匹配。 示例 1: 输入: s = "aa" p = "a" 输出: false 解释: "a" 无法匹配 "aa" 整个字符串。 示例 2: 输入: s = "aa" p = "a*" 输出: tr
剑指offer：18-21记录
少说，多做。
03-09 9574
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2: 输入: head = [4,5,1,...
剑指offer面试题19：正则表达式匹配
宋铮的博客
06-08 617
题目 请实现一个函数用来匹配包括’.’和’*’的正则表达式。模式中的字符’.’表示任意一个字符，而‘*’表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串”aaa”与模式”a.a”和”ab*ac*a”匹配，但是与”aa.a”和”ab*a”均不匹配。 class Solution { public: bool match(char*...
剑指Offer 面试题19：正则表达式匹配 Java代码实现
hh_zheng的博客
11-20 2596
题目：正则表达式匹配 请实现一个函数用来匹配包含'.'和'*'的正则表达式。字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次） 主要思想就是字符的第一个字符和模式第一个字符相匹配，那么字符串和模式都向后移动一个字符继续匹配；出现不匹配时直接返回false。但是当第二个字符是'*'时，比较复杂，可以有不同的匹配方式。 具体来说：
剑指Offer——面试题19：正则表达式匹配
01-06
面试题19：正则表达式匹配 题目：请实现一个函数用来匹配包含’.‘和’*‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’*’表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符...
ruoruochen#front-end-note#【剑指Offer 19】正则表达式匹配1
07-25
例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。示例 2:输入:解释: 因为 '*' 代表可以匹配零个或多个
【剑指offer】面试题19：正则表达式匹配
Java学习
01-05 518
题目：请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。 例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配  链接：https://www.nowcoder.com/questionTermin...
剑指Offer 19.正则表达式匹配（Python）
ChungChinKei' blog
06-03 414
题目介绍 请实现一个函数用来匹配包括 . 和 * 的正则表达式。模式中的字符 . 表示任意一个字符，而 * 表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。 字符串"aaa"与模式"a.a"和"ab*ac*a"匹配； 字符串"aaa"与"aa.a"和"ab*a"均不匹配。 题目解读 我们可以先从 * 字符进行入手，因为 * 字符相对于 . 字符来说...
计算两个字符串之间的编辑距离的Python实现
仰起脸笑得像满月
05-15 5513
假设给定两个字符串str1和str2，如果我们想把str1变为str2，这一过程中所需的最少的插入、删除和替换等基本操作的个数称为str1与str2之间的编辑距离。比如如果想把字符串abandon变为aband最好的方案是删除on这两个字母，因而它们之间的编辑距离就是2；同样如果想把abandon变为abanded最优的方案是把最后的on替换为ed，需要替换两个字母，所以它们之间的编辑距离也是2。...
字符ASCII码排序
仰起脸笑得像满月
03-11 5302
描述： 输入三个字符（可以重复）后，按各字符的ASCII码从小到大的顺序输出这三个字符。 输入： 第一行输入一个数N,表示有N组测试数据。后面的N行输入多组数据，每组输入数据都是占一行，有三个字符组成，之间无空格。 输出： 对于每组输入数据，输出一行，字符中间用一个空格分开。 这个题实际上就是要实现一个排序，这里使用的是冒泡排序法。代码如下： import java.ut
CCF认证模拟题——分蛋糕
仰起脸笑得像满月
05-30 3836
问题描述 　　小明今天生日，他有n块蛋糕要分给朋友们吃，这n块蛋糕（编号为1到n）的重量分别为a1, a2, …, an。小明想分给每个朋友至少重量为k的蛋糕。小明的朋友们已经排好队准备领蛋糕，对于每个朋友，小明总是先将自己手中编号最小的蛋糕分给他，当这个朋友所分得蛋糕的重量不到k时，再继续将剩下的蛋糕中编号最小的给他，直到小明的蛋糕分完或者这个朋友分到的蛋糕的总重量大于等于k。 　　请问
CCF认证模拟题——学生排队
仰起脸笑得像满月
05-30 3008
问题描述 　　体育老师小明要将自己班上的学生按顺序排队。他首先让学生按学号从小到大的顺序排成一排，学号小的排在前面，然后进行多次调整。一次调整小明可能让一位同学出队，向前或者向后移动一段距离后再插入队列。 　　例如，下面给出了一组移动的例子，例子中学生的人数为8人。 　　0）初始队列中学生的学号依次为1, 2, 3, 4, 5, 6, 7, 8； 　　1）第一次调整，命令为“3号同学向
LeetCode的SQL题练手（MySQL实现）
仰起脸笑得像满月
09-15 2731
Contens175 组合两个表官方解法备注181 超过经理收入的员工我的解法182 查找重复的电子邮箱我的解法解法二183 从不订购的客户我的解法官方解法197 上升的温度我的错误题解正确题解569 超过5名学生的课我的错误解法正确解法力扣精选70题1068 产品销售分析 I解法1303 求团队人数解法1069 产品销售分析II解法613 直线上的最近距离解法1251 平均售价解法584 寻找用户推荐人解法1173 即时食物配送 I解法LeetCode官方给出的另外两种解法1082 销售分析 I解法105
LeetCode华为模拟面试
仰起脸笑得像满月
11-17 1478
这是一篇灌水的博客。 今天收到了华为2012实验室的面试通知，HR老师说手撕代码很重要，遂在LeetCode上进行了一次华为题库的模拟面试，下面是这次模拟面试的三道题目。 面试结果：全部通过 总时长：1 小时 30 分 耗时：46 分 19 秒 答题数：3/3 一、二叉搜索树转化为累加和 给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。 提醒一下，二叉搜索树满足下列约
区间子数组个数
仰起脸笑得像满月
04-07 1090
@author: sdubrz @date: 2020.03.26 题目难度： 中等 原题链接 https://leetcode-cn.com/problems/number-of-subarrays-with-bounded-maximum/ 题目的著作权归领扣网络所有，商业转载请联系官方授权，非商业转载请注明出处。 解题代码转载请联系 lwyz521604#163.com 给定一个元素都是正...
剑指offer刷题笔记
仰起脸笑得像满月
10-05 969
最近LeetCode上的《剑指offer》的题刷的差不多了，只剩几道无聊的题了。现在把做题过程中的记录放在这里，作为将来查看的笔记，也同时欢迎大家指出其中的不当之处（QQ）。虽然博主现在仍然没有拿到offer，但应该正如二师兄所言“放屁添风”，相信也是有些许的参考意义的。 Contens04 二维数组中的查找我的解法官方给出的线性解法05 替换空格我的解法官方解法06 从尾到头打印链表我的解法官方解法07 重建二叉树我的解法官方递归解法官方迭代解法09 用两个栈实现队列我的解法网友的解法10 青蛙跳台阶问题
Java正则表达式完全指南：从基础到应用
- 正则表达式匹配：如剑指Offer面试题19，考察对正则表达式复杂性的理解和运用。 掌握Java正则表达式对于解决日常的字符串处理问题至关重要，无论是简单的验证还是复杂的文本分析，它都是不可或缺的工具。通过不断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值