剑指offer-面试题19：正则表达式匹配 双序列动态规划

题目描述

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

示例 1:
输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。

示例 2:
输入:
s = “mississippi”
p = “misisp*.”
输出: false

本题在LeetCode官网上被分类为hard，确实有点困难，反正作者是看了LeetCode上网友的题解后才做出来的，这是参考的题解：LeetCode官网题解

接下来整理一下解题思路和代码

双序列动态规划解法

对于长度为m的主串s和长度为n的模式串p，我们建立一个二维动规表：boolean[][] dp=new boolean[m+1][n+1]，dp[i][j]记录主串s的第0到i-1号元素和模式串p的第0到j-1号元素是否匹配。为什么尺寸是[m+1][n+1]呢，因为需要考虑边界情况且便于后续计算

• 首先考虑边界情况：主串和模式串均为空时可以匹配；主串不为空但模式串为空时不匹配；当主串为空，模式串不为空时，只有像 a*b*…f* 这样的模式串和主串匹配，其余模式串均不匹配
• 对于不是边界情况的dp[i][j]：
  • p[j-1]==’.'时，因为‘.’可以表示任意一个字符，需考虑前面的串是否匹配，dp[i][j]=dp[i-1][j-1]
  • p[j-1]是普通字母时，若s[i-1]!=p[j-1]，两字母不相同，dp[i][j]=false；否则两字母相同，需看前面的串是否匹配，dp[i][j]=dp[i-1][j-1]
  • p[j-1]==‘*’时，我们需要考虑模式串中 ‘*’ 前的字母p[j-2]与主串当前字母s[i-1]是否相同，若相同，可以考虑两种操作，将 ‘*’ 前的字母使用0次，看dp[i][j-2]或使用不少于1次，看dp[i-1][j]；若不相同，则只能考虑使用0次的操作
• 最终返回dp[m][n]为最终结果

因为题目属于有两个序列需要我们去考虑，使用动规解决这类问题的方法叫做“双序列动态规划”

状态转移方程：

/*边界情况*/
dp[i][j]=true                             //i=0,j=0
dp[i][j]=false                            //i>0,j=0
dp[i][j]=true                             //i=0,j%2==0,dp[i][j-2]=true,p[j-1]=='*'
dp[i][j]=false                            //i=0,!(j%2==0 && dp[i][j-2] =true && p[j-1]=="*")
/*非边界情况*/
//当p[j-1]=='.'
dp[i][j]=dp[i-1][j-1]
//当p[j-1]=='*'
dp[i][j]=(dp[i][j-2] || dp[i-1][j])       //s[i-1]==p[j-2] || p[j-2]=='.'
dp[i][j]=dp[i][j-2]                       //s[i-1]!=p[j-2] && p[j-2]!='.'
//当p[j-1]是普通字母
dp[i][j]=dp[i-1][j-1]                     //s[i-1]==p[j-1]
dp[i][j]=false                            //s[i-1]!=p[j-1]

完整代码：

class Solution {
    public boolean isMatch(String s, String p)
    {
        //用于动规的二位表，dp[i][j]记录主串s的第0到i-1号元素和模式串p的第0到j-1号元素是否匹配
        boolean[][] dp=new boolean[s.length()+1][p.length()+1];
        //对第一行和第一列进行初始化
        dp[0][0]=true; //主串和模式串均为空时匹配
        for(int i=1;i<dp[0].length;i++) //主串为空模式串不为空时，只有 a*b*...f* 类型的模式串才能匹配
        {
            if(i%2==0 && p.charAt(i-1)=='*' && dp[0][i-2])
            {
                dp[0][i]=true;
            }
            else
            {
                dp[0][i]=false;
            }
        }
        for(int i=1;i<=s.length();i++)
        {
            for(int j=1;j<=p.length();j++)
            {
                char ch1=s.charAt(i-1);
                char ch2=p.charAt(j-1);
                if(ch2=='.')
                {
                    dp[i][j]=dp[i-1][j-1];
                }
                else if(ch2=='*')
                {
                    if(ch1==p.charAt(j-2) || p.charAt(j-2)=='.')
                    {
                        dp[i][j]=(dp[i][j-2] || dp[i-1][j]);
                    }
                    else
                    {
                        dp[i][j]=dp[i][j-2];
                    }
                }
                else //ch2是普通字母
                {
                    if(ch1==ch2)
                    {
                        dp[i][j]=dp[i-1][j-1];
                    }
                    else
                    {
                        dp[i][j]=false;
                    }
                }
            }
        }
        return dp[s.length()][p.length()];
    }
}

时间复杂度：O(mn)
空间复杂度：O(mn)