用dfs或动态规划实现正则表达式匹配

正则表达式是通常被用来检索、替换那些符合某个模式(规则)的文本，即记录文本规则的代码。

dfs方法

class Solution {
    public boolean isMatch(String s, String p) {
     if(p==".*")return true;
     return getmatch(s,p,0,0);
    }
    public boolean getmatch(String s,String p,int m,int n){
     if(p.length()==n)return s.length()==m;
     boolean prematch=(m!=s.length())&&(s.charAt(m)==p.charAt(n)||p.charAt(n)=='.'); 
         if(n+1!=p.length()&&p.charAt(n+1)=='*')
          return prematch&&getmatch(s,p,m+1,n)||getmatch(s,p,m,n+2);
          else
          return prematch&&getmatch(s,p,m+1,n+1);

    }
}

动态规划+bfs

class Solution {
    public boolean isMatch(String s, String p) {
        int n = s.length();
        int m = p.length();
        boolean[][] dp = new boolean[n + 1][m + 1];
        //S和P都为空时，匹配
        dp[0][0] = true;
        //当S为空，P不空，要看P是否为 a*b*这种结构
        for(int j = 1; j <= m; ++j) {
            if(p.charAt(j - 1) == '*') {
                dp[0][j] = dp[0][j - 2];
            }
        }
        for(int i = 1; i <= n; ++i) {
            for(int j = 1; j <= m; ++j) {
                //当前字符串是*，可以将 字符+*全部忽略掉，取f[i][j-2]的值
                //或者看模式串P的上一个字符串是否能跟字符串S匹配
                //如果能匹配上，可以忽略掉模式串的 字符+*，也可以忽略掉字符串S中的当前字符
                //这里其实跟递归一样，也有两条转移路径
                if(p.charAt(j - 1) == '*') {
                    if(p.charAt(j - 2) == '.'||p.charAt(j - 2) == s.charAt(i - 1)) {
                        dp[i][j] = dp[i - 1][j] || dp[i][j - 2];
                    }
                    else {
                        dp[i][j] = dp[i][j - 2];
                    }
                }
                //单个字符匹配的情况     
                else {
                    if(p.charAt(j - 1) == s.charAt(i - 1) || p.charAt(j - 1) == '.') {
                        dp[i][j] = dp[i - 1][j - 1];
                    }
                }
            }
        }
        return dp[n][m];
    }    
}