leetcode10.正则表达式匹配（动态规划）

给你一个字符串 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
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
 

提示：

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

大概题意就是给定两个字符串s,p，实现s,p的关于给定规则的正则表达式匹配。按照用例试一下，可以发现很明显的动态规划特征。 若给定字符串

s：abc

p：b*c*a*b*c*

由于“*”前字母的个数可以是任意个，所以 需要判断任意数量的字母的情况下是否匹配，这样的话就有很多种可能，根据每一个“*”的数量做对比，复杂度很高，基本上实现不了。所以想到是否可以通过动态规划来减少计算量。考虑到动态规划需要无后效性，即后面的状态不会影响到前面的状态，可以考虑状态为dp[i][j]，表示s的前i个字符是否和p的前j个字符匹配。由于“*”作用于其前面的一个字符，所以从后往前扫描会好处理一些，所以定义dp[i][j]，表示s的第i之后的字符是否和p的第j位字符匹配。若扫描到p中"*"，则让其于前面的一个字符绑定求解状态。

根据p中的字符，分类讨论得出状态转移方程。

dp[i][j]=dp[i+1][j+1]&&(s[i]==p[j])(p[j]为字母)

dp[i][j]=dp[x][j](若p[j-1]p[j]为".*"，x大于等于i，若存在前面状态为真则存在一个状态转移到他为真)

dp[i][j]=dp[x][j]&&...(若"*"前为字母，联系之前已经求出的状态，讨论字母的个数,若存在一个可以为真的状态，则其为真)

class Solution {
public:
        bool isMatch(string s, string p) {
            s=s+"#",p=p+"#";
            int lens=s.size(),lenp=p.size(),x=lenp;
            s="#"+s,p="#"+p;//预处理，防止越界错误
            if(s[lens]!=p[lenp]&&p[lenp]!='.'&&p[lenp]!='*')return false;
            bool dp[50][50];
            memset(dp,0,sizeof(dp));
            while(lenp>=1){
                int i=lens;
                while(i>=0){
                    if(p[lenp]=='*'){
                    if(p[lenp-1]!='.'){
                        while(i>=0){
                            int a=i;
                            dp[i][lenp]=dp[i][lenp+1];
                            dp[i][lenp-1]=dp[i][lenp];
                            while((a<=lens-1&&p[lenp-1]==s[a])){
                                dp[i][lenp]=(dp[i][lenp]||dp[a+1][lenp+1]);
                                dp[i][lenp-1]=(dp[i][lenp-1]||dp[a+1][lenp+1]);
                                a++;
                            }
                            i--;
                        }
                    }
                    else {
                        while(i>=0){
                            int a=i;
                            while(a<=lens){
                                dp[i][lenp]=(dp[i][lenp]||dp[a][lenp+1]);
                                dp[i][lenp-1]=(dp[i][lenp]||dp[a][lenp+1]);
                                a++;
                            }
                            i--;
                            }
                    }
                        lenp--;
                    }//第一类，"x*"和".*"
                    else if(p[lenp]=='.'){
                        if(!(lenp==x&&i==lens))dp[i][lenp]=dp[i+1][lenp+1];
                        else dp[i][lenp]=true;
                        i--;
                    }//第二类，"."
                    else{
                        if(!(i==lens&&lenp==x))dp[i][lenp]=(s[i]==p[lenp]&&(dp[i+1][lenp+1]));
                        else dp[i][lenp]=(s[i]==p[lenp]);
                        i--;
                    }//第三类，"x"
                }
                lenp--;
            }
        return dp[1][1];
    }
};

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/regular-expression-matching
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。