【数据结构与算法】leetcode刷题记录(正则表达式匹配) ---＞暴力--＞优化暴力---＞记忆性递归

正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

示例 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
 

提示：

        0 <= s.length <= 20
        0 <= p.length <= 30
        s 可能为空，且只包含从 a-z 的小写字母。
        p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
        保证每次出现字符 * 时，前面都匹配到有效的字符

java

1.暴力递归

class Solution {
   public boolean isMatch(String s, String p) {
        if(p.isEmpty()){
            return s.isEmpty();
        }
        boolean firstflag = !s.isEmpty() && ((s.charAt(0)==p.charAt(0) || p.charAt(0)=='.'));
        if(p.length()>=2 && p.charAt(1)=='*'){
            return isMatch(s,p.substring(2)) ||(firstflag&&isMatch(s.substring(1),p));
        }
        return firstflag&&isMatch(s.substring(1),p.substring(1));
    }
}

2.优化暴力递归

charAt方法调用次数过多,可以使用char数组来记录,减少charAt次数

class Solution {
    public boolean isMatch(String s, String p) {
        char[] sarr = s.toCharArray();
        char[] parr = p.toCharArray();
        return isMatchChar(sarr,0,parr,0);
    }
    public boolean isMatchChar(char[] ss,int sstart,char[] pp,int pstart){
        if(pp.length<=pstart)
            return (ss.length<=sstart);
        boolean firstFlag = (ss.length>sstart)&&((ss[sstart]==pp[pstart])||(pp[pstart]=='.'));
        if((pp.length-pstart)>=2&&pp[pstart+1]=='*'){
            return isMatchChar(ss,sstart,pp,pstart+2)||(firstFlag&&isMatchChar(ss,sstart+1,pp,pstart));
        }
        return firstFlag&&isMatchChar(ss,sstart+1,pp,pstart+1);
    }
}

3.使用记忆数组优化递归

使用int[ ] [ ]一个二维数组 , 用来存储比较的结果 , 减少比较的次数,

当 数组中位置为sstart行pstart列的位置不为0时,返回该位置结果即可;

class Solution {
    int[][] flag;
    public boolean isMatch(String s, String p) {
        this.flag = new int[s.length()+1][p.length()+1];
        char[] sarr = s.toCharArray();
        char[] parr = p.toCharArray();
        return isMatchChar(sarr,0,parr,0);
    }
    public boolean isMatchChar(char[] ss,int sstart,char[] pp,int pstart){
        if(pp.length<=pstart)
            return (ss.length<=sstart);
        if(flag[sstart][pstart]!=0)
            return flag[sstart][pstart]>0;
        boolean firstFlag = (ss.length>sstart)&&((ss[sstart]==pp[pstart])||(pp[pstart]=='.'));
        if((pp.length-pstart)>=2&&pp[pstart+1]=='*'){
            boolean t = isMatchChar(ss,sstart,pp,pstart+2)||(firstFlag&&isMatchChar(ss,sstart+1,pp,pstart));
            if(t)
                flag[sstart][pstart]=1;
            else 
                flag[sstart][pstart]=-1;
            return t;
        }
        boolean t = firstFlag&&isMatchChar(ss,sstart+1,pp,pstart+1);
        if(t)
            flag[sstart][pstart]=1;
        else 
            flag[sstart][pstart]=-1;
        return t;
    }
}

4.(猴戏 )使用java自带的正则

class Solution {
    public boolean isMatch(String s, String p) {
        return s.matches(p);
    }
}