leetcode_【10】正则表达式匹配

1.题目描述

给定一个字符串 (s) 和一个字符模式 (p)。实现支持 '.' 和 '*' 的正则表达式匹配。

‘.’ 匹配任意单个字符。
‘*’ 匹配零个或多个前面的元素。

匹配应该覆盖整个字符串 (s) ，而不是部分字符串。

说明:

• s 可能为空，且只包含从 a-z 的小写字母。
• p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例 1:

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

示例 2:

输入:
s = “aa”
p = “a*”
输出: true
解释: ‘*’ 代表可匹配零个或多个前面的元素, 即可以匹配 ‘a’ 。因此, 重复 ‘a’ 一次, 字符串可变为 “aa”。

示例 3:

输入:
s = “ab”
p = “."
输出: true
解释: ".” 表示可匹配零个或多个(’*’)任意字符(’.’)。

示例 4:

输入:
s = “aab”
p = “cab”
输出: true
解释: ‘c’ 可以不被重复, ‘a’ 可以被重复一次。因此可以匹配字符串 “aab”。

示例 5:

输入:
s = “mississippi”
p = “misisp*.”
输出: false

2.解题思路

方法1：

跟剑指offer的52题一致

这道题的核心其实在于分析’’,对于’.‘来说，它和任意字符都匹配，可把其当做普通字符。对于’'的分析，我们要进行分情况讨论，当所有的情况都搞清楚了以后，就可以写代码了。

情况1：Patttern第二个字符是’*'时：

1.第一个字符不匹配（’.‘与任意字符视作匹配），那么’*'只能代表匹配0次

‘ba’与’a*ba’，字符串不变，模式向后移动两个字符，然后匹配剩余字符串和模式

2.第一个字符匹配，那么’*'可能代表匹配0次，1次，多次，

(1)‘aaa’与’a*aaa’: 匹配0次时，字符串不变，模式向后移动两个字符，然后匹配剩余字符串和模式；

(2)‘aba’与’a*ba’:匹配1次时，字符串往后移动一个字符，模式向后移动2个字符；

(3)‘aaaba’与’a*ba’:匹配多次时，字符串往后移动一个字符，模式不变；

情况2：Patttern第二个字符不是’*'时：

(1)如果字符串的第一个字符和模式中的第一个字符匹配，那么在字符串和模式上都向后移动一个字符，然后匹配剩余字符串和模式。

(2)如果字符串的第一个字符和模式中的第一个字符不匹配，那么直接返回false。

方法2：动态规划

定义一个dp[][]数组，其中d[i][j]表示s[0,i]和p[0][j]是否匹配

dp初始化:dp[0][0] = true，代表str为空串，pattern为空串的情况

    求dp[0][j]即求str为空串，pattern是否匹配
    当遇到后一个为 * 时，且dp[0][i-1]为true则匹配(匹配前面字符0次)，标记dp[0][i+1] = true

情况1：当前字母匹配，str和pattern都往后移动一位

             dp[i+1][j+1] = dp[i][j]

情况2：后一个pattern是 * ,前一个pattern跟str不匹配,str不变，pattern后移动两位

             dp[i+1][j+1] = dp[i+1][j-1]

情况3：后一个pattern是 * ,前一个pattern跟str匹配

    (1)匹配0次，str不动，pattern后移2位
            dp[i+1][j+1] = dp[i+1][j-1]
            
    (2)匹配一次，str移动1位，pattern移动2位
            dp[i+1][j+1] =dp[i][j-1]
            
    (3)匹配多次，str移动1次，pattern不动
            dp[i+1][j+1] = dp[i][j+1]

3.代码

方法1：

     public static boolean isMatch(String str, String pattern) {
            if (str == null || pattern == null)
                return false;

            return matchCore(str.toCharArray(), 0, pattern.toCharArray(), 0);
        }
        public static boolean matchCore(char[] str, int strIndex, char[] pattern, int patternIndex) {
            //有效性检验：str到尾，pattern到尾，匹配成功
            if (strIndex == str.length && patternIndex == pattern.length) {
                return true;
            }
            //pattern先到尾，匹配失败
            if (strIndex != str.length && patternIndex == pattern.length) {
                return false;    }
            //模式第2个是*，且字符串第1个跟模式第1个匹配,分3种匹配模式；如不匹配，模式后移2位
            //   //如果当前pattern的下一个是*并且没有超出pattern的长度时
            if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
                // //如果当前字符str[index]和pattern[index]相等，或者当前pattern为‘.’
                if ((strIndex != str.length && pattern[patternIndex] == str[strIndex]) || (pattern[patternIndex] == '.' && strIndex != str.length)) {
                    return matchCore(str, strIndex, pattern, patternIndex + 2)//模式后移2，视为x*匹配0个字符(当前pattern[index+1]='*'且str[index]!=pattern[index]）
                            || matchCore(str, strIndex + 1, pattern, patternIndex + 2)//视为模式匹配1个字符 (当前pattern[i+1]='*'且str[index]=pattern[index])
                            || matchCore(str, strIndex + 1, pattern, patternIndex);//*匹配1个，再匹配str中的下一个（当前pattern[index]='.'）
                } else {
                    //当前字符str[index]和pattern[index]不相等&&当前pattern不为‘.’
                    return matchCore(str, strIndex, pattern, patternIndex + 2);
                }
            }
            //模式第2个不是*，且字符串第1个跟模式第1个匹配，则都后移1位，否则直接返回false
            //pattern[index]='.'的情况，strindex和pattern都加1向下匹配
            if ((strIndex != str.length && pattern[patternIndex] == str[strIndex]) || (pattern[patternIndex] == '.' && strIndex != str.length)) {
                return matchCore(str, strIndex + 1, pattern, patternIndex + 1);
            }
            return false;
        }

方法2：动态规划

 public static boolean isMatch(String s, String p) {

            if (s == null || p == null) {
                return false;
            }
            boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];
            //i= 0，j= 0表示str和pattern为空串，匹配成功标true
            dp[0][0] = true;
            //str为空串，pattern不为空串的情况
            for (int i = 0; i < p.length(); i++) {
                //前一个为true后一个为*，*匹配0个，则标记下一个为true
                if (p.charAt(i) == '*' && dp[0][i - 1]) {
                    dp[0][i + 1] = true;
                }
            }
            for (int i = 0; i < s.length(); i++) {
                for (int j = 0; j < p.length(); j++) {
                    //当前字母匹配，字符str和pattern都后移动一位
                    if (p.charAt(j) == '.' || p.charAt(j) == s.charAt(i)) {
                        dp[i + 1][j + 1] = dp[i][j];
                    }
                    //后一个字符是*
                    if (p.charAt(j) == '*') {
                        //str与pattern不匹配
                        if (p.charAt(j - 1) != s.charAt(i) && p.charAt(j - 1) != '.') {
                            //str不变，pattern后移动两位
                            dp[i + 1][j + 1] = dp[i + 1][j - 1];
                        } else {
                            //匹配0次，str不动，pattern后移2位，匹配一次，str移动一位，pattern移动2位，匹配多次，str移动1次，pattern不动
                           dp[i + 1][j + 1] = (dp[i + 1][j-1] || dp[i][j - 1] || dp[i][j + 1]);

                        }
                    }
                }

            }
            return dp[s.length()][p.length()];
        }

4.提交记录

方法1

方法2：