Sword refers to offer 19. Regular expression matching

1. Description of the topic

Please implement a function to match regular expressions containing '. ' and "*". The character '.' in the mode means any character, and "*" means that the character in front of it can appear any number of times (including 0 times). In this question, matching means that all characters of the string match the entire pattern. For example, the string "aaa" matches the patterns "aa" and "ab*ac*a", but neither "aa.a" nor "ab*a".

Example 1

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

Example 2

输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。

Example 3

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。

Example 4

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

Example 5

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

2. Solution: dynamic programming

Ideas and Algorithms

The matching in the title is a "step-by-step matching" process: each time we start from the string ppTake out a character or a combination of "character + asterisk" from$p$$s$ to match. For a character in , it can only be in$Match\; a\; character\; in\; s$ , the matching method is unique; and for
ppAs far as the combination of character + asterisk in$p$$s$ matches any natural number of characters and is not unique. Therefore, we can consider using dynamic programming to enumerate the matching schemes.

We use $f\left[i\right]\left[j\right]$ meansssex iiof$s$$i$ characters andppex jjin$p$$Whether\; j$ characters can be matched. When doing state transitions, we consider$p$ 'sjjthMatching of$j\; characters:$

• if $p$ 's$j$ characters is a lowercase letter, then we must in$s$ matches an identical lowercase letter, ie

$$f[i][j]=\{\begin{array}{ll}f[i-1][j-1],& \text{s[i]=p[j]}\\ false,& \text{s[i]=p[j]}\end{array}$$
That is, if $s$ second$i$ characters and$p$ 's$j$ characters are not the same, then the match cannot be performed; otherwise we can match the last character of the two strings, and the complete matching result depends on the previous part of the two strings.

• if $p$ 's$j$ characters are * then it means we can$p$ 's$j-1$ character matches any natural number of times. In the case of 0 matches, we have$$f[i][j]=f[i][j-2]$$
  That is, we "wasted" a combination of characters + asterisks, which did not match anysscharacters in$s\; .$
  In the case of matching 1,2,3,⋯ times, similarly we have
  
  If we transfer through this method, then we need to enumerate this combination to match$s$ , a few characters will increase the time complexity, and the code is very cumbersome to write. We might as well consider this problem from another angle: in the process of matching letters + asterisks, there are essentially only two situations:
  • match $A\; character\; at\; the\; end\; of\; s$ , the character is thrown away, and the combination can continue to match;
  • No character is matched, the combination is discarded and no further matching is performed.
    If we think from this perspective, we can write a very delicate state transition equation:
    
  • In any case, as long as $p\left[j\right]$ is. , then$p\left[j\right]$ must successfully matchssAny lowercase letter in$s\; .$

The final state transition equation is as follows:

where $matches(x,y)$ Auxiliary function to judge whether two characters match, only when$y$ is. or$x$和$These\; two\; characters\; will\; only\; match\; if\; y$ itself is the same.

detail

The boundary condition of dynamic programming is $f[0][0]=true$ , that is, two empty strings can be matched. The final answer is$f\left[m\right]\left[n\right]$ where$m$ and$n$ is the string ssrespectively$s$ and$the\; length\; of\; p$ . . Because in most languages, the character subscript of a string starts from 00, so when implementing the above state transition equation, it is necessary to pay attention to the corresponding relationship between each dimension subscript in the state and the actual character subscript.
In the above state transition equation, if the string p contains a combination of "character + asterisk" (such as a*), then a will be matched first when the state transition is performed (when p [ j ] p$p\left[j\right]$ is a), then match a* as a whole (when$p\left[j\right]$ is *). However, in the topic description, we must regard a* as a whole, so matching a does not meet the requirements of the topic.

3. Code snippet

class Solution {
    
    
public:
   bool isMatch(string s, string p) {
    
    
       int m = s.size();
       int n = p.size();

       auto matches = [&](int i, int j) {
    
    
           if (i == 0) {
    
    
               return false;
           }
           if (p[j - 1] == '.') {
    
    
               return true;
           }
           return s[i - 1] == p[j - 1];
       };

       vector<vector<int>> f(m + 1, vector<int>(n + 1));
       f[0][0] = true;
       for (int i = 0; i <= m; ++i) {
    
    
           for (int j = 1; j <= n; ++j) {
    
    
               if (p[j - 1] == '*') {
    
    
                   f[i][j] |= f[i][j - 2];
                   if (matches(i, j - 1)) {
    
    
                       f[i][j] |= f[i - 1][j];
                   }
               }
               else {
    
    
                   if (matches(i, j)) {
    
    
                       f[i][j] |= f[i - 1][j - 1];
                   }
               }
           }
       }
       return f[m][n];
   }
};

4. Complexity analysis

• Time complexity: $O\left(mn\right)$ where m and n are the lengths of strings s and p respectively. We need to calculate all the states, and the time complexity of each state transition is$O(1)$。
• Space complexity: $O\left(mn\right)$ , which is the space used to store all states.
  Reference link: https://leetcode.cn/problems/regular-expression-matching/solution/zheng-ze-biao-da-shi-pi-pei-by-leetcode-solution/