力扣困难级别-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
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
 

提示：

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

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

/**
 * @param {string} s
 * @param {string} p
 * @return {boolean}
 */
var isMatch = function(s, p) {
    //用隐马尔科夫链条的思路，每次根据上一次的状态生成下一次的状态，最后判断最长的链条
    let preList = [0];
    let list = [];
    for (let i = 0; i < p.length; i++) {
        if (p[i + 1] === '*') {
            preList.forEach(function(k) {
                let pos = k;
                if(list.indexOf(pos)===-1){
                        list.push(pos);
                    }
                while (pos < s.length && (p[i] === '.' || p[i] === s[pos])) {
                    pos++;
                    if(list.indexOf(pos)===-1){
                        list.push(pos);
                    }
                }

            });
            i++;
        } else {
            preList.forEach(function(pos) {
                if (pos < s.length && (p[i] === '.' || p[i] === s[pos])) {
                    if(list.indexOf(pos+1)===-1){
                        list.push(pos+1);
                    }
                }

            })

        }
        //更新链条，进入下一次循环
        preList = list;
        list = [];
    }
    //判断最长链条
    let isOk = false
    for (let i = 0; i < preList.length; i++) {
        if (preList[i] === s.length) {
            isOk = true
            break
        }
    }
    return isOk;
};

 

 

/**

 * @param {string} s

 * @param {string} p

 * @return {boolean}

 */

var isMatch = function(s, p) {

    //用隐马尔科夫链条的思路，每次根据上一次的状态生成下一次的状态，最后判断最长的链条

    let preList = [0];

    let list = [];

    for (let i = 0; i < p.length; i++) {

        if (p[i + 1] === '*') {

            preList.forEach(function(k) {

                let pos = k;

                if(list.indexOf(pos)===-1){

                        list.push(pos);

                    }

                while (pos < s.length && (p[i] === '.' || p[i] === s[pos])) {

                    pos++;

                    if(list.indexOf(pos)===-1){

                        list.push(pos);

                    }

                }

            });

            i++;

        } else {

            preList.forEach(function(pos) {

                if (pos < s.length && (p[i] === '.' || p[i] === s[pos])) {

                    if(list.indexOf(pos+1)===-1){

                        list.push(pos+1);

                    }

                }

            })

        }

        //更新链条，进入下一次循环

        preList = list;

        list = [];

    }

    //判断最长链条

    let isOk = false

    for (let i = 0; i < preList.length; i++) {

        if (preList[i] === s.length) {

            isOk = true

            break

        }

    }

    return isOk;

};