剑指Offer-正则表达式匹配

题目描述

请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配。

拿到题目要先审题，注意输入输出，输入的两个数组，str对应的是只包含英文的字符串，pattern对应的是包含*.的字符串。

使用递归求解

解题思路—递归-先匹配 * ：

当pattern中的第二个字符不是 * 时：

1. 如果str中的第1个字符和pattern中的第1个字符相匹配，那么str和pattern都后移一位，继续匹配；
2. 如果str中第1个字符和pattern中的第1个字符不匹配，直接返回false。

当pattern中的第二个字符是 * 时：

1. 如果str中第1个字符跟pattern中第1个字符不匹配，则pattern后移2维，继续匹配；
2. 如果str中第1个字符跟pattern中第1个字符匹配，则有以下3种情况：
   （1）pattern后移2位，相当于x* 出现0次；
   （2）str后移1位，pattern后移2位，相当于x* 出现1次；
   （3）str后移1位，pattern不变，即继续匹配str下一位，相当于x* 出现多次。

解题思路—递归-先匹配英文字符：

先记录str中的第1个字符与pattern中的第1个字符是否匹配（包含有 . 字符情况），若匹配，isMatch=true；反之，isMatch=false。
如果pattern中第二个字符是 * ，有以下2种情况：

1. 如果isMatch==true，str后移1位，pattern不变，即继续匹配str下一位；
2. 不考虑isMatch状态，pattern后移2位。

如果pattern中第二个字符不是 * ，有以下2种情况：

1. 如果isMatch==true，那么str和pattern都后移一位，继续匹配；
2. 如果isMatch==false，直接返回false。

使用动态规划求解

解题思路—动态规划-先匹配 *：

动态规划与直接递归的不同之处在于，动态规划使用数组保存每一步出现的结果。因为字符串全部匹配成功，才输出true，所以本题动态规划使用反向遍历。将保存结果的数组的最右下角的值置为true，即dp[str.length+1][pattern.length+2]=true，dp数组其余全部置为false，在反向遍历的过程中，不断地将最后的true向数组前端传递，若字符串完全匹配，最后true将会传递到dp[0][0]，dp[0][0]的值即为匹配结果。
核心判断思想与递归-先匹配 * 是一样的，就是一定要特别注意数组有没有越界！

解题思路—动态规划-先匹配英文字符：

核心思想与递归-先匹配英文字符一样，都是先匹配当前字符，再判断pattern下一个字符是否为 * 。同样，一定要特别注意数组有没有越界！

Java解题—递归-先匹配 *

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null || pattern == null)
            return false;
        return Match(str, 0, pattern, 0);
    }
    
    public boolean Match(char[] str, int a, char[] pattern, int b){
        // 同时检测到数组尾部
        if(str.length==a && pattern.length==b)
            return true;
        // 字符串还有，匹配的到尾了，匹配失败
        if(str.length!=a && pattern.length==b)
            return false;
        // pattern中匹配到'*'
        if(b+1<pattern.length && pattern[b+1]=='*'){
            if(a!=str.length && (pattern[b]==str[a] || pattern[b]=='.')){
                return Match(str, a, pattern, b+2)  // pattern中x*为出现0次
                        || Match(str, a+1, pattern, b+2)  // pattern中x*为出现1次
                        || Match(str, a+1, pattern, b); // pattern中x*为出现多次
            }else{
                return Match(str, a, pattern, b+2); // str已经结束了
            }
        }

        if(a!=str.length && (pattern[b]==str[a] || pattern[b]=='.'))
            return Match(str, a+1, pattern, b+1);

        return false;
    }
}

Java解题—递归-先匹配英文字符

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null || pattern == null)
            return false;
        return Match(str, 0, pattern, 0);
    }
    
    public boolean Match(char[] str, int a, char[] pattern, int b){
        // 同时检测到数组尾部
        if(str.length==a && pattern.length==b)
            return true;
        // 字符串还有，匹配的到尾了，匹配失败
        if(str.length!=a && pattern.length==b)
            return false;
        // 匹配当前字符
        boolean isMatch = a!=str.length && (str[a]==pattern[b] || pattern[b]=='.');

        if(b+1<pattern.length && pattern[b+1]=='*')
            return Match(str, a, pattern, b+2) 
            || (isMatch && Match(str, a+1, pattern, b)); 
        else
            return (isMatch && Match(str, a+1, pattern, b+1)); // 继续匹配
    }
}

Java解题—动态规划-先匹配 *

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null || pattern == null)
            return false;
        boolean [][] dp = new boolean[str.length + 1][pattern.length + 1];
        dp[str.length][pattern.length] = true;
        //开始循环
        for (int i = str.length; i >= 0; i--) {  // str从空串开始匹配，防止str有长度为0的情况
            for (int j = pattern.length - 1; j >= 0; j--) {   // pattern从最后一个字符开始匹配
                if(j < pattern.length - 1 && pattern[j + 1] == '*') {
                    // 当前字符匹配
                    if(i < str.length && (str[i] == pattern[j] || pattern[j] == '.'))
                        dp[i][j] = dp[i][j + 2] || dp[i + 1][j];
                    else // 当前字符不匹配
                        dp[i][j] = dp[i][j + 2];
                }else { //若不是"*"，判断是否匹配
                    if(i!= str.length && (str[i] == pattern[j] || pattern[j] == '.'))   // 当前字符匹配
                        dp[i][j] = dp[i + 1][j + 1];
                }
            }
        }
        return dp[0][0];
    }
}

Java解题—动态规划-先匹配英文字符

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null || pattern == null)
            return false;
        boolean [][] dp = new boolean[str.length + 1][pattern.length + 1];
        dp[str.length][pattern.length] = true;

        for (int i = str.length; i >= 0; i--) { // str从空串开始匹配，防止str有长度为0的情况
            for (int j = pattern.length - 1; j >= 0; j--) {// pattern从最后一个字符开始匹配
                // 判断当前字符是否匹配 ，保存结果
                boolean isMatch = (i != str.length) &&
                        (str[i] == pattern[j] || pattern[j] == '.');
                // 如果pattern下一个字符是“*”
                if(j < pattern.length - 1 && pattern[j + 1] == '*') {
                    dp[i][j] = dp[i][j + 2] || ( isMatch && dp[i + 1][j]);
                }else {
                    dp[i][j] = isMatch && dp[i + 1][j + 1];
                }
            }
        }
        return dp[0][0];
    }
}