leetcode 10. 正则表达式匹配

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

'.' 匹配任意单个字符

'*' 匹配零个或多个前面的那一个元素

所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。

说明:

s 可能为空，且只包含从 a-z 的小写字母。

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

 

题解：

1.一个字符串 s 和一个字符规律 p

2.s 可能为空，且只包含从 a-z 的小写字母

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

4.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

解题思路：

• 设二维数组存放状态转移，dp[i][j]表示s的前i个字符匹配p前j个字符

• 根据初始值，s的前0个字符匹配p前0个字符为true,以此为初始值，初始化s的前0个字符匹配p前j个字符,其它出*号初始化false,因为*可以表示前面的字符0个

• 从s和p的第2个字符开始判断以下情况

• 如果匹配字符串中当前字符和s中当前遍历字符相同，或是对应p的"." "."表示任意字符，可以匹配s中字符，此种情况s的前i个字符匹配p前j个字符的值等于s的前i-1个字符匹配p前j-1个字符

• 如果p遇到了*号，*号表示前一个字符0个或多个，则取决于s的前i个字符匹配p前j-2个字符情况；

• 若s中第i个字符与p中第j-1个字符相同，或者p中第j-1个字符是.(.表示任意字符)，与后面的*配合都能使s中前i个字符与p中前j个字符匹配，所以取决于s中前i-1个字符与p中前j个字符匹配

• 最后s整个字符串和p整个字符串匹配关系表示为dp[s.size()][p.size()]

C/C++题解：

class Solution {

public:

    bool isMatch(string s, string p) {

        //状态转移方程dp[i][j]表示s的前i个字符匹配p前j个字符

        // dp[i][j] => is s[0, i - 1] match p[0, j - 1] ?

        vector<vector<bool>> dp(s.size() + 1,vector<bool>(p.size() + 1));

        dp[0][0] = true;//前0个字符匹配前0个字符，为true

        for (int i = 1; i <= p.size(); ++i) {

            //*表示前一个字母重复，如果遍历到i-1是*则字母在i-2

            dp[0][i] = p[i - 1] == '*' ? dp[0][i - 2] : false;}//*可以表示前面的字符0个

        for (int i = 1; i <= s.size(); ++i) {

            for (int j = 1; j <= p.size(); ++j) {

                //字母相同或是.(.表示任意字符，可以匹配字母)

                if (s[i - 1] == p[j - 1] || p[j - 1] == '.') {

                    // 看 s[0,...i-1] 和 p[0,...j-1]满足条件在i,j上是能匹配的

                    //所以整体取决于i-1,j-1

                    dp[i][j] = dp[i - 1][j - 1];}

                if (p[j - 1] == '*') {//如果是*号，表示*号前的字符

                    //*号在j-1位置，表示的字符在p中为j-2位置

                    // 看 s[0,...i] 和 p[0,...j-2]

                    dp[i][j] = dp[i][j] | dp[i][j - 2];

                    if (p[j - 2] == s[i - 1] || p[j - 2] == '.') {

                        //p中j-2字符和s中i-1字符相同，则*位置也同于s中i-1

                        //.表示任意字符，所以也同于s中i-1

                        // 看 s[0,...i-1] 和 p[0,...j]

                        dp[i][j] = dp[i][j] | dp[i - 1][j]; }}}

        }//最后，值传递到[s.size()][p.size()]位置

        //表示s整个字符串和p整个字符串匹配关系

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

Debug结果：

Java题解：

 

class Solution {

    public boolean isMatch(String s, String p) {

        //状态转移方程dp[i][j]表示s的前i个字符匹配p前j个字符

        char[] sArr = s.toCharArray();

        char[] pArr = p.toCharArray();

        // dp[i][j] => is s[0, i - 1] match p[0, j - 1] ?

        boolean[][] dp = new boolean[sArr.length + 1][pArr.length + 1];

        dp[0][0] = true;//前0个字符匹配前0个字符，为true

        for (int i = 1; i <= pArr.length; ++i) {

            //*表示前一个字母重复，如果遍历到i-1是*则字母在i-2

            dp[0][i] = pArr[i - 1] == '*' ? dp[0][i - 2] : false;}

        for (int i = 1; i <= sArr.length; ++i) {

            for (int j = 1; j <= pArr.length; ++j) {

                //字母相同或是.(.表示任意字符，可以匹配字母)

                if (sArr[i - 1] == pArr[j - 1] || pArr[j - 1] == '.') {

                    // 看 s[0,...i-1] 和 p[0,...j-1]满足条件在i,j上是能匹配的

                    //所以整体取决于i-1,j-1

                    dp[i][j] = dp[i - 1][j - 1];}

                if (pArr[j - 1] == '*') {//如果是*号，表示*号前的字符

                    //*号在j-1位置，表示的字符在p中为j-2位置

                    // 看 s[0,...i] 和 p[0,...j-2]

                    dp[i][j] = dp[i][j] | dp[i][j - 2];

                    if (pArr[j - 2] == sArr[i - 1] || pArr[j - 2] == '.') {

                        //p中j-2字符和s中i-1字符相同，则*位置也同于s中i-1

                        //.表示任意字符，所以也同于s中i-1

                        // 看 s[0,...i-1] 和 p[0,...j]

                        dp[i][j] = dp[i][j] | dp[i - 1][j];}}}}

        //最后，值传递到[sArr.length][pArr.length]位置

        //表示s整个字符串和p整个字符串匹配关系

        return dp[sArr.length][pArr.length];}}

Debug结果：

Python题解：

class Solution(object):

    def isMatch(self, s, p):

        """:type s: str:type p: str:rtype: bool"""

        #状态转移方程dp[i][j]表示s的前i个字符匹配p前j个字符

        #dp[i][j] => is s[0, i - 1] match p[0, j - 1] ?

        m,n=len(s),len(p)

        dp=[[False]*(n+1) for _ in range(m+1)]

        dp[0][0] = True #前0个字符匹配前0个字符，为true

        for i in range(1, n+1):

            #表示前一个字母重复，如果遍历到i-1是*则字母在i-2

            if p[i - 1] == '*':

                dp[0][i] = dp[0][i - 2]

            else: dp[0][i] = False

        for i in range(1, m+1):

            for j in range(1, n+1):

                #字母相同或是.(.表示任意字符，可以匹配字母)

                if s[i - 1] == p[j - 1] or p[j - 1] == '.':

                    #看 s[0,...i-1] 和 p[0,...j-1]满足条件在i,j上是能匹配的

                    #所以整体取决于i-1,j-1

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

                if p[j - 1] == '*': #如果是*号，表示*号前的字符

                    #*号在j-1位置，表示的字符在p中为j-2位置

                    #看 s[0,...i] 和 p[0,...j-2]

                    dp[i][j] = dp[i][j] | dp[i][j - 2]

                    if p[j - 2] == s[i - 1] or p[j - 2] == '.':

                        #p中j-2字符和s中i-1字符相同，则*位置也同于s中i-1

                        #.表示任意字符，所以也同于s中i-1

                        #看 s[0,...i-1] 和 p[0,...j]

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

        #最后，值传递到[s.size()][p.size()]位置

        #表示s整个字符串和p整个字符串匹配关系

        return dp[m][n]

Debug结果：

更多题解移步公众号免费获取