剑指 Offer 19. 正则表达式匹配

题目描述：

      请实现一个函数用来匹配包含.'和 * 的正则表达式。模式中的字符.表示任意一个字符，而 * 表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab * ac * a"匹配，但与"aa.a"和"ab*a"均不匹配。
示例1：
输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。

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

示例3：
输入:
s = “ab”
p = ". * "
输出: true解释: “.*” 表示可匹配零个或多个（’ * ‘）任意字符（’.’）。

解题思路：

1、动态规划：
     设主串为A，模式串为B，长度分别为n，m。设f[i][j]表示A的前i个和B的前j个是否能匹配，假如已知f[i][j]之前的状态，那么f[i][j]的状态取决于B[j]的值。
     B[j]的值有三种情况：（1）当B[j]为正常字符时，判断A[i]是否B[j]，如果不等则不能匹配，否则看f[i-1][j-1]，即f[i][j] = f[i-1][j-1]；（2）当B[j]为’.‘时，即可以匹配任意字符，f[i][j] = f[i-1][j-1]；（3）当B[j]为’*'时。表示字符B[j-1]可以重复0次或者多次（B[j-1] *），这个时候有两种情况：一是A[i]不等于B[j-1]，那么B[j][j-1]是无效的， 即f[i][j] = f[i][j-2]；二是A[i]等于B[j-1]，B[j][j-1]是有效的，可以继续匹配A[i]前面的字符，同时也可能出现B[j - 1]*为空的情况，即f[i][j] = f[i-1][j] or f[i][j - 2]，这个时候状态转移方程已经出来了。
     下面考虑初始状态，有几种情况：（1）主串为空串，模式串为空串，这个时候肯定是匹配的，即f[0][0]=true；（2）主串为非空串，模式串为空串，这个时候肯定不匹配，即f[1][0]=...=f[n][0]=false；（3）主串为空串，模式串为非空串和主串为非空串，模式串为非空串这两种情况都不能直接确定状态，需要计算。
注意点：上面的A[i]和B[j]都是指串的第i和j个字符，在编程的时候需要留意。上述的过程也可以基于递归实现。

实现代码：

	//解法1：动态规划
    public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
        boolean[][] f = new boolean[m + 1][n + 1];
        for(int i = 0; i <= m; i++)
            for(int j = 0; j <= n; j++){
                if(j == 0)
                    f[i][j] = i == 0;
                else {
                    if(p.charAt(j - 1) != '*'){
                        if(i > 0 && (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '.'))
                            f[i][j] = f[i - 1][j - 1];
                    }
                    else {
                        //不看*
                        if(j >= 2)
                            f[i][j] |= f[i][j - 2];//使用|是因为只要有一种情况是true则f[i][j]就是true
                        //看*
                        if(i > 0 && j >= 2 && (s.charAt(i - 1) == p.charAt(j - 2) || p.charAt(j - 2) == '.'))
                            f[i][j] |= f[i - 1][j];
                    }
                }
            }
        return f[m][n];
    }


    //解法2：递归
    public boolean isMatch1(String s, String p) {
        if(s.length() == 0){
            if(p.length() % 2 == 1)//当s长度为0且p长度为奇数时肯定不匹配
                return false;
            int i = 1;
            while(i < p.length()){
                if(p.charAt(i) != '*')//如果p不是c*b*这种类型也不匹配
                    return false;
                i += 2;
            }
            return true;
        }
        if(p.length() == 0)
            return false;
        char s1 = s.charAt(0), p1 = p.charAt(0), p2 = 'a';
        if(p.length() > 1)
            p2 = p.charAt(1);
        if (p2 != '*') {
            if(s1 == p1 || p1 == '.')
                return isMatch1(s.substring(1),p.substring(1));
            return false;
        }else {
            //如果该字符相等，有两种情况:看*和不看*
            if(s1 == p1 || p1 == '.')
                return isMatch1(s.substring(1),p) || isMatch1(s,p.substring(2));
            //如果该字符不相等，则*肯定不看
            else
                return isMatch1(s,p.substring(2));
        }
    }