【leetcode】10. 正则表达式匹配（动态规划：用二维数组表示s的前i个字符与p中的前j个字符是否匹配。考虑p[j]字符分别为字母/./*时的状态，转移至前续状态）

题目

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

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

说明:

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

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

动态规划

官方分析连接

class Solution {
public:
    bool isMatch(string s, string p) {
        int slen = s.length(), plen = p.length();
        bool flag[slen+1][plen+1];
        for( int i=0; i<slen+1; i++ ){
            for( int j=0; j<plen+1; j++ ){
                flag[i][j] = false;
            }
        }
        flag[0][0] = true; //边界条件：两个空字符串为真
        for(int i=0; i<=slen; i++){
            for(int j=0; j<=plen; j++){ //应该从j=0开始，但是因为还需要判断p的下标[j-1]，所以直接从j=1开始吧
                if( j < 1 )
                    continue;
                if( p[j-1] != '*' ){
                    if( i>=1 && match(s[i-1], p[j-1])){ //注意判断s的下标i
                        flag[i][j] |= flag[i-1][j-1];
                    }else{
                        // flag[i][j] |= false;
                    }
                }else{ // *
                    if( i>=1 && match(s[i-1], p[j-2])){
                        flag[i][j] |= (flag[i-1][j] || flag[i][j-2]);
                    }else{
                        flag[i][j] |= flag[i][j-2];
                    }
                }
            }
        }
        return flag[s.length()][p.length()];
    }
    bool match(char sch, char pch){
        return pch=='.' || pch==sch;
    }
};

复杂度分析
时间复杂度：O(mn)，其中 m 和 n 分别是字符串 s和 p 的长度。我们需要计算出所有的状态，并且每个状态在进行转移时的时间复杂度为 O(1)。
空间复杂度：O(mn)，即为存储所有状态使用的空间。