题目描述

给你一个字符串 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 的小写字母，以及字符 . 和 *。
• 保证每次出现字符 * 时，前面都匹配到有效的字符

解题思路

• 这道题确实很hard。我们来分析一下，题目就是让我们判断正则表达式是否匹配字符串。我们可以用动态规划的思想去考虑：
  • 首先建立状态f[i][j]表示字符串前i个字母与正则表达式前j个字母是否匹配。
  • 先考虑一下边界f[0][0]==true，f[i][0]==true，那f[0][j]呢？根据规则，.*可以匹配空格，
• 对于f[i][j],他由什么转化而来，我们从p[j]来看
  • 当p[j]是字母并且等于s[i],f[i][j]=f[i-1][j-1],否则f[i][j]=false
  • 当p[j]=.时,相当于最后一个直接匹配，f[i][j]=f[i-1][j-1]。
  • 当p[j]=*时,再根据j前面的分类讨论
    • 当p[j-1]是字母时，todu 回头补充
    • 当p[j-1]是.时，todu 回头补充
    • 当p[j-1]是*时,和没有一样，f[i][j]=f[i][j-2]

func isMatch(s string, p string) bool {
   f := make([][]bool, len(s)+1)
   for i := 0; i < len(f); i++ {
      f[i] = make([]bool, len(p)+1)
   }
   f[0][0] = true
   for i := 1; i < len(p); i++ {
      if p[i] == '.' {
         if i == 1 {
            f[0][i] = true
         } else {
            f[0][i] = f[0][i-2]
            if p[i-1] == '.' {
               f[0][i] = f[0][i] || f[0][i-1]
            }
         }
      }
   }
   for i := 0; i < len(s); i++ {
      for j := 0; j < len(p); j++ {
         if p[j] >= 'a' && p[j] <= 'z' {
            if s[i] == p[j] {
               f[i+1][j+1] = f[i][j]
            } else {
               f[i+1][j+1] = false
            }
         } else if p[j] == '.' {
            f[i+1][j+1] = f[i][j]
         } else if p[j] == '*' {
            if p[j-1] >= 'a' && p[j-1] <= 'z' {
               f[i+1][j+1] = f[i+1][j-1]
               if s[i] == p[j-1] {
                  f[i+1][j+1] = f[i+1][j+1] || f[i][j-1]
                  k := i - 1
                  for k >= 0 && f[i+1][j+1] == false && s[k] == s[k+1] {
                     f[i+1][j+1] = f[i+1][j+1] || f[k][j-1]
                     k--
                  }
               }
            } else if p[j-1] == '*' {
               f[i+1][j+1] = f[i+1][j]
            } else if p[j-1] == '.' {
               f[i+1][j+1] = f[i+1][j-1]
               k := 0
               for k < len(s) && f[i+1][j+1] == false {
                  f[i+1][j+1] = f[k][j-1]
                  k++
               }
            }
         }
      }
   }
   return f[len(s)][len(p)]
}