Leetcode10 dynamic programming realizes simple regular matching

topic:

Realize simple regular matching

---

Solution: dynamic programming

Characters: .and a~z.
Quantity:, *which is a whole with the character before it.

a*The structure of the specific implementation of several a's function rules is very complicated, it is impossible to write if directly, so you need to enumerate all the situations (the role of 0~n a), and one of the matches is successful even if it is successful.

• Select state
  dp[i][j]represents s[0~i]the p[0~j]match.
• The state transition equation
  $$dp[i][j]=\{\begin{array}{ll}dp[i-1][j-1]& p[j]!{=}^{\prime }{\ast }^{\prime }Andcheck\left(s\right[i],p[j])\\ false& p[j]!{=}^{\prime }{\ast }^{\prime }And!check\left(s\right[i],p[j\left]\right)\\ dp[i][j-2]& p[j]={=}^{\prime }{\ast }^{\prime }And!check\left(s\right[i],p[j-1])\\ Hairwaving0thDP\left[I\right][J-2]||hairwaving.\; 1thDP[I-1][j-2]||hairwavingpluralitythDP[I-1][j]& p\left[j\right]={=}^{\prime }{\ast }^{\prime }Andcheck\left(s\right[i],p[j-1])\end{array}$$
  0<=i<s.length(), 0<=j<p.length()
  Where the check function is:

bool check(char a, char b){
    
    
        if(a=='.' || b=='.') return true;
        else return a==b;
    }

So far there are still two problems that need to be solved:

1. If you enter an empty string, an error will occur when opening the array.
   The matching of empty strings and the matching of normal strings use the same set of methods, and one character can be added at the beginning or the end ?. That is, let the input string length be at least 1.
2. Negative subscripts (boundaries) may appear in the state transition equation.
   For guarantee i,j>=1, the characters of string can be numbered starting from 1. Combining with the first question, you can insert a "starting symbol" at the beginning of the string uniformly.

• Boundary
  Row 0, column 0 needs to be initialized:
  dp[0][0] = true
dp[i][0] = false, 1<=i<s.length()

$$\begin{gathered} 1<=j<p.length() \\ dp[0][j]=\{\begin{array}{ll}dp[0][j-2]& p[j]={=}^{\prime }{\ast }^{\text{'}}(Likein\ast Thejasetisan\; evennumber)\\ false& p[j]!{=}^{\prime }{\ast }^{\prime }\end{array} \end{gathered}$$

• The processing sequence
  involves the points on the left, above, and above the current point. The processing sequence is from top to bottom and from left to right.

class Solution {
    
    
public:
    bool isMatch(string s, string p) {
    
    
        s.insert(s.begin(), '?');
        p.insert(p.begin(), '?');
        int slen=s.length(), plen=p.length();
        //初始化
        bool dp[slen][plen]={
    
    };
        dp[0][0] = true;
        for(int j=1; j<plen; j++){
    
    
            if(p[j]=='*') dp[0][j] = dp[0][j-2];
        }
        //填表
        for(int j=1; j<plen; j++){
    
    
            for(int i=1; i<slen; i++){
    
    
                if(p[j]=='*'){
    
    
                    if(check(s[i], p[j-1])) dp[i][j] = dp[i][j-2]||dp[i-1][j-2]||dp[i-1][j];
                    else dp[i][j] = dp[i][j-2];
                }
                else{
    
    
                    if(check(s[i], p[j])) dp[i][j] = dp[i-1][j-1];
                    else dp[i][j] = false;
                }
            }
        }
        return dp[slen-1][plen-1];
    }

    bool check(char a, char b){
    
    
        if(a=='.' || b=='.') return true;
        else return a==b;
    }
};