Sword finger Offer 19. Regular expression matching

subject

Please implement a function to match regular expressions containing '.' and '*'. The character '.' in the mode indicates any character, while '*' indicates that the character before it can appear any time (including 0 times). In this question, matching means that all characters of the string match the whole pattern. For example, the string "aaa" matches the patterns "a.a" and "abaca", but not "aa.a" and "ab*a".

Example 1:
Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" cannot match "aa" the entire string.

Example 2:
Input:
s = "aa"
p = "a*"
Output: true
Explanation: because '*' means that zero or more preceding elements can be matched, the preceding element here is' a '. Therefore, the string "aa" can be regarded as' a 'repeated once.

Example 3:
Input:
s = "ab"
p = "."
Output: true
Explanation: "." means that it can match zero or more ('*') arbitrary characters ('.').

Example 4:
Input:
s = "aab"
p = "cab"
Output: true
Explanation: because '*' represents zero or more, here 'c' is 0, and 'a' is repeated once. Therefore, the string "aab" can be matched.

Example 5:
Input:
s = "mississippi"
p = "misisp*."
Output: false

s may be empty and contain only lowercase letters from a-z.
p may be empty and contain only lowercase letters from a-z and the characters. And *, with no consecutive '*'.
Note: this question is the same as question 10 of the main station: https://leetcode-cn.com/problems/regular-expression-matching/

Source: LeetCode
Link: https://leetcode-cn.com/problems/zheng-ze-biao-da-shi-pi-pei-lcof

Problem solving ideas

Method 1: "cheating"
Directly use the function matches provided by java to judge whether the string matches the regular expression. Actually, the static method of Pattern is called.

Law 2: violence recursion
When writing, you should think clearly and judge whether the given regular expression is empty. When both p and s are empty, it proves that the matching is successful. After excluding this situation, judge whether the first character of S and p matches.
When the next character of p is * look at the matching result of the first character in front.
Mismatch, p moves back two bits during recursion, and s remains unchanged.
Match, then s moves back one bit and p remains unchanged during recursion.
If the first characters of s and p are equal, the remaining strings are recursive.

Method 3: dynamic programming
Dynamic programming should first find laws and transfer equations.
If you look at the previous solution, you can get:
f[0][0] = true when both string and expression are empty
f[i][j] = f[i-1][j-1]
When the current character does not match, but the next digit is *, f[i][j] = f[i][j-2]
When the current character matches and the next digit is *, f[i][j] = f[i-1][j]

java code

//FA Yi
class Solution {
    public boolean isMatch(String s, String p) {
        return s.matches(p);//Matches checks whether the string matches the given regular expression
    }
}

//Method II
class Solution {
    public boolean isMatch(String s, String p) {
    //If p is empty and s is also empty, the matching is successful
    if (p.isEmpty()){
        return s.isEmpty();
    }
    //Determine whether the first character of s and p matches
    boolean headMatched = !s.isEmpty() && (s.charAt(0)==p.charAt(0)||p.charAt(0)=='.');
    if (p.length()>=2 && p.charAt(1)=='*'){//If the next element of the first element of p is*
        return isMatch(s,p.substring(2)) || (headMatched&&isMatch(s.substring(1),p));
    }
    else if (headMatched){//If the first characters of s and p are equal
        return isMatch(s.substring(1),p.substring(1));
    }
    else {
        return false;
    }
  }
}

//Method three
class Solution {
    public boolean isMatch(String s, String p) {
        int lens = s.length();
        int lenp = p.length();
        //Initialize dynamic programming matrix
        boolean[][] dp = new boolean[lens+1][lenp+1];
        dp[0][0] = true;//Both are space-time matching
        for(int j = 2; j < lenp+1; j += 2){//initialization
            dp[0][j] = dp[0][j - 2] && p.charAt(j - 1) == '*';
        }
            
        for(int i = 1; i < lens+1; i++) {
            for(int j = 1; j < lenp+1; j++) {
                if(p.charAt(j - 1) == '*'){
                    dp[i][j] = dp[i][j - 2] || dp[i - 1][j] && (s.charAt(i - 1) == p.charAt(j - 2) || p.charAt(j - 2) == '.');
                }
                else{
                    dp[i][j] = dp[i - 1][j - 1] && (p.charAt(j - 1) == '.' || s.charAt(i - 1) == p.charAt(j - 1));
                }                    
            }
        }
        return dp[lens][lenp];
    }
 }