2021-07-21 10.正则表达式匹配（动态规划）

注：

题目：
给你一个字符串 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 = “cab”
输出：true
解释：因为 '’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。
示例 5：
输入：s = “mississippi” p = "misisp."
输出：false

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

题解：
1.定义状态
定义动态数组dp[m][n],(n为字符串p的长度+1,m为字符串s的长度+1)，
Q：思考为什么要 +1呢？
A：因为我们还要处理空字符串的情况，比如说p为空,s为空时什么情况；或者p为空,s不为空时什么情况？
那么dp[m][n]的含义是：p的前n个字符能否匹配s的前m个字符。比如说dp[1][1]是看s[0]和p[0]能否匹配。

有以下三种情况是需要我们处理的：
（1）p[j] 为字母
如果s[i] == p[j]，则我们只需要看一下前面的dp[i-1][j-1]的状态，dp[i][j]继续延续即可！即动态转移方程为：dp[i][j]=dp[i-1][j-1]。
如果s[i] != p[j]，则dp[i][j]=false

（2）p[j] == '.'
我们只需要看一下前面的dp[i-1][j-1]的状态，dp[i][j]继续延续即可！即动态转移方程为：dp[i][j]=dp[i-1][j-1]

（3）p[j] == '*'
此时也需要区分两种情况
① s[i] == p[j-1] || p[j-1] == '.'
如果*的前一个字符正好对应了s,状态转移过程为:dp[i][j]=dp[i-1][j].

如果是 * 的前一个字符为 . 那我们只需要看 . 的前面字符匹配情况，状态转移过程为：dp[i][j]=dp[i][j-2].

② !(s[i] == p[j-1] || p[j-1] == ‘.’)
动态转移方程为: d[r][c] = dp[r][c-2]

class Solution {
public:
    bool match(int i,int j,string s,string p){
        if(i==0){
            return false;
        }
        else if(p[j-1]=='.'){
            return true;
        }
        else if(p[j-1]==s[i-1]){
            return true;
        }
        else{
            return false;
        }
    }
    bool isMatch(string s, string p) {
        int m=s.size();
        int n=p.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        dp[0][0]=true;
        for(int i=0;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(p[j-1]!='*'){
                    if(match(i,j,s,p)){
                        dp[i][j]=dp[i-1][j-1];
                    }
                    else{
                        dp[i][j]=0;
                    }
                }
                else{
                    if(match(i,j-1,s,p)){
                        dp[i][j]=dp[i-1][j]||dp[i][j-2];
                    }
                    else{
                        dp[i][j]=dp[i][j-2];
                    }
                }
            }
        }
        return dp[m][n];
    }
};