2021.10.12 - JZ19.正则表达式匹配

1. 题目

2. 思路

(1) 动态规划

• 定义动态规划矩阵dp[][]，dp[i][j]表示字符串s的前i个字符与字符串p的前j个字符是否匹配，注意矩阵下标比字符串下标大1，即矩阵中的i-1在字符串中为i。
• 状态转移的难点在于p中的当前字符是’*'时的情况：
  1. 当dp[i][j-2]=true时，匹配，即将p中的前一个字符看作出现0次；
  2. 当dp[i-1][j]=true且p(j-2)=s(i-1)时，匹配，即将p中的前一个字符看作出现2次；
  3. 当dp[i-1][j]=true且p(j-2)=’.'时，匹配，即将p中的前一个字符看作s中的当前字符且出现2次。

3. 代码

public class Test {
     
    public static void main(String[] args) {
     
    }
}

class Solution {
     
    public boolean isMatch(String s, String p) {
     
        int m = s.length() + 1;
        int n = p.length() + 1;
        boolean[][] dp = new boolean[m][n];
        //首行表示s是空字符串的状态，首列表示p是空字符串的状态
        dp[0][0] = true;
        //初始化首行，若是奇数列则必然不匹配，若是偶数列则前一个偶数列匹配且当前字符为*时匹配
        for (int j = 2; j < n; j += 2) {
     
            dp[0][j] = dp[0][j - 2] && p.charAt(j - 1) == '*';
        }
        //状态转移，注意下标
        //数组中的i-1指前一个字符，字符串中的i-1指当前字符
        for (int i = 1; i < m; i++) {
     
            for (int j = 1; j < n; j++) {
     
                if (dp[i - 1][j - 1] && (p.charAt(j - 1) == '.' || p.charAt(j - 1) == s.charAt(i - 1))) {
     
                    //s中的前一个字符与p中的前一个字符匹配，且p中的当前字符为.或p中的当前字符与s中的当前字符匹配
                    dp[i][j] = true;
                } else if (p.charAt(j - 1) == '*') {
     
                    //p中的当前字符为*
                    if (dp[i][j - 2]) {
     
                        //s中的当前字符与p中的前两个字符匹配，因为p中的前一个字符可被当前字符*抵消
                        dp[i][j] = true;
                    } else if (dp[i - 1][j] && (p.charAt(j - 2) == '.' || p.charAt(j - 2) == s.charAt(i - 1))) {
     
                        //s中的前一个字符与p中的当前字符匹配，且p中的前一个字符为.或p中的前一个字符与s中的当前字符匹配
                        dp[i][j] = true;
                    }
                }
            }
        }
        return dp[m - 1][n - 1];
    }
}