正则表达式匹配（超级重要，因为difficult）

1.题目

2.解法（动态规划）

public class Solution {
    // 1.实现一个匹配函数
    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[0][0] = true;

        // 为了处理aab和c*aab这种情况，因为后面处理的时候，会漏掉这种情况，所以这里补充
        for (int i = 0; i < pattern.length; i++) {
            if(pattern[i] == '*' && dp[0][i-1]){
                dp[0][i+1] = true;
            }
        }

        for (int i = 0; i < str.length ; i++) {
            for (int j = 0; j < pattern.length; j++) {
                // 情况1：对应位置的元素相等 例如 aa和aa
                if(str[i] == pattern[j]){
                    // 字符串的下标从0开始，为了对应，所以为i+1和i
                    dp[i+1][j+1] = dp[i][j];
                }
                // 情况2：对应位置有. 例如 aa和a.
                if(pattern[j] == '.'){
                    dp[i+1][j+1] = dp[i][j];
                }

                // 情况3： 对应位置有*
                if(pattern[j] == '*'){
                    // 情况3.1 例如 ba 和 b*， *代表的是b, 这里不能出现ba 和 .*的情况，因为结果为true,不能往前挪动
                    if(pattern[j-1] != str[i] && pattern[j-1] != '.'){
                        dp[i+1][j+1] = dp[i+1][j-1];
                    } else {
                        // 情况3.2 pattern[j-1] == str[i] or pattern[j-1] == '.'
                        /**
                         * 这里分为3种情况：
                         * 3.2.1： aa 和 a*，*只重复1次
                         * 3.2.2：aaaa 和 a*， *重复多次 这里先利用3.2.1的情况，aa和a*先比
                         * 3.2.3：aaa 和 c*aaa， *重复0次，c*应该为空
                         */
                        // 三种情况中的一种否合要求就可(因为是i和j控制的双层循环，每种情况都会考虑到）
                        dp[i+1][j+1] = (dp[i+1][j] || dp[i][j+1] || dp[i+1][j-1]);
                    }
                }
            }
        }

        return dp[str.length][pattern.length];
    }
}

时间复杂度和空间复杂度的均为O(str.length * pattern.length)