一天一大 leet(正则表达式匹配)难度:困难 DAY-20

程序员文章站 2022-05-07 23:02:38

...

20200620

题目(难度:困难):

给你一个字符串 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

抛砖引玉

一天一大 leet(正则表达式匹配)难度:困难 DAY-20

题目要求完成的逻辑为:

// p中只包含.*及a-z
new RegExp(p).test(s);

采用逐位匹配
假设知道了,s前i-1和p前j-1位是否匹配，当判断i位是否只需要知道i和j位是否配置
如果匹配那字符串匹配的结果就和前i-1匹配的结果一样
$f[i][j] = f[i-1][j-1]$
如果s与p都为空则返回true，则f[0][0] = true
f[i][j]为s的第n-1个字符与p的第j-1位匹配

i和j是否匹配的情况包括:

s[i-1]等于p[j-1]
p[j-1]为.
p[j-1]为*
- s[i-1]等于p[j-2]
- s[p-2]等于.

匹配过程中字符匹配和.与字符匹配都比较简单，复杂的为*匹配

*结合合字符 -> (0-n)字符
.结合* -> 任意长度任意字符

逐位匹配

p[j-1]为*

匹配0个字符，拿s的前i字符与p的前j-2(排除末尾的 $*$ 其前一个字符)个规则匹配
匹配n个字符，拿s的第i字符与p的第j-1(排除末尾的 $*$ )匹配,匹配通过则s的第i为和第i-1位都可适用改规则

/**
 * @param {string} s
 * @param {string} p
 * @return {boolean}
 */
var isMatch = function(s, p) {
	let m = s.length, n = p.length, f = new Array(m + 1);
	for (let v = 0; v < m + 1; v++) f[v] = new Array(n + 1);
	f[0][0] = true;
	for (var i = 0; i <= m; ++i) {
		for (var j = 1; j <= n; ++j) {
			if (p.charAt(j - 1) == '*') {
				f[i][j] = f[i][j - 2];
				if (matches(s, p, i, j - 1)) {
					f[i][j] = f[i][j] || f[i - 1][j];
				}
			}
			else {
				if (matches(s, p, i, j)) {
					f[i][j] = f[i - 1][j - 1];
				}
			}
		}
	}
	function matches(s, p, i, j) {
		if (i == 0) {
			return false;
		}
		if (p.charAt(j - 1) == '.') {
			return true;
		}
		return s.charAt(i - 1) == p.charAt(j - 1);
	}
	return Boolean(f[m][n]);
}

其他解法

/**
 * @param {string} s
 * @param {string} p
 * @return {boolean}
 */
var isMatch = function(s, p) {
    if (s == null || p == null) return false
  let len1 = s.length, len2 = p.length
  let dp = new Array(len1 + 1)
  for (let i = 0; i < dp.length; i++) 
    dp[i] = new Array(len2 + 1).fill(false) // 将项默认为false

  dp[0][0] = true
  for (let j = 1; j < len2 + 1; j++) {
    if (p[j - 1] == '*')
      dp[0][j] = dp[0][j - 2]
  }
  for (let i = 1; i < len1 + 1; i++) {
    for (let j = 1; j < len2 + 1; j++) {
      if (s[i - 1] == p[j - 1] || p[j - 1] == ".") {
        dp[i][j] = dp[i - 1][j - 1] 
      } else if (p[j - 1] == "*") { 
        if (s[i - 1] == p[j - 2] || p[j - 2] == ".")
          dp[i][j] = dp[i][j - 2] || dp[i - 1][j - 2] || dp[i - 1][j]
        else
          dp[i][j] = dp[i][j - 2] 
      }
    }
  }
  return dp[len1][len2] // len1长度的s串 是否匹配 len2长度的p串
};

如果p为空，s为空匹配，s非空不匹配；
s非空，p == s || p == '.'时第一个字符匹配；
(p+1) != ‘’，则递归判断剩下的是否匹配 first_match && isMatch(++s, ++p)
(p+1) == ‘*’，则有两种情况匹配：

*匹配0个字符，s匹配剩下的，即isMatch(s, p+2)
*匹配1个字符，继续用p匹配剩下的s，即first_match && isMatch(s+1, p)

/**
 * @param {string} s
 * @param {string} p
 * @return {boolean}
 */
  var isMatch = function (s, p) {
    if (p.length < 1) {
      return !s.length
    }
    var match = false

    if (s.length > 0 && (s[0] == p[0] || p[0] == '.')) {
      match = true
    }
    if (p.length > 1 && p[1] == '*') {
      return match && isMatch(s.slice(1), p) || isMatch(s, p.slice(2))
    } else {
      return match && isMatch(s.slice(1), p.slice(1))
    }
  }