String、动态规划——正则表达式匹配

题目描述：

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

递归法在leetcode上超时通不过。

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str == null||pattern == null)
            return false;
        return matchCore(str,0,pattern,0);
    }
    public boolean matchCore(char[] str,int sindex,char[]pattern,int pindex)
        {
        if(sindex == str.length&&pindex == pattern.length)
            return true;
        if(pindex == pattern.length&&sindex!=str.length)
            return false;
        if(sindex == str.length&&pindex<pattern.length)
            {
             if(pindex+1<pattern.length&&pattern[pindex+1]=='*')
                 return matchCore(str,sindex,pattern,pindex+2);
            else
                return false;
        }
        
        if(pindex+1<pattern.length&&pattern[pindex+1] == '*')
            {
            if(pattern[pindex]==str[sindex]||pattern[pindex]=='.')
                {
                return matchCore(str,sindex+1,pattern,pindex+2)||
                       matchCore(str,sindex+1,pattern,pindex)||
                       matchCore(str,sindex,pattern,pindex+2);
            }
            if(pattern[pindex]!=str[sindex])
                {
                return  matchCore(str,sindex,pattern,pindex+2);
            }
        }
        else if(pattern[pindex]==str[sindex]||pattern[pindex]=='.')
            {
            return matchCore(str,sindex+1,pattern,pindex+1);
        }
           
            return false;
    }
}

动态规划法：用空间换时间
boolean型辅助矩阵flag[i][j]表示s.length == i and p.length == j 时匹配情况
。自底向上的动态规划法：
1.边界条件在矩阵中赋值；
2.一般条件使用递推公式自底向上对矩阵赋值；
3.返回flag[i][j]的值，即为s字符串长度为i,p为j时的匹配情况。

public class Solution {
    public boolean isMatch(String s, String p) {
        if(s == null||p == null)
            return false;
        boolean [][]flag=new boolean[100][100];
        //flag[i][j]表示s.length == i and p.length == j 时匹配情况
        //使用自底向上的方法
        flag[0][0]=true;
       
        int m=s.length()+1;
        int n=p.length()+1;
        //s.length!=0,p.length == 0时，全部为false;  
        for(int i=1;i<m;i++)
            {
            flag[i][0]=false;
        }
        //p.length!=0,s.length == 0时的情况。
        for(int j=1;j<n;j++)
            {
            if(j>=2&&p.charAt(j-1) == '*')//去掉p.charAt(0) == '*'的情况；
                {
                flag[0][j]=flag[0][j-2];
            }else
                {
                flag[0][j]=false;
            }
        }
        
        for(int i=1;i<m;i++)
            {
            for(int j=1;j<n;j++)
                {
                if(j>=2&&p.charAt(j-1) == '*')//去掉p.charAt(0) == '*'的情况；
                    {
                    if(p.charAt(j-2) == s.charAt(i-1)||p.charAt(j-2) == '.')
                        {
                    flag[i][j]=flag[i][j-2]||flag[i-1][j]||flag[i-1][j-2];          
                    }
                    else
                        {
                        flag[i][j]=flag[i][j-2];
                    }   
                }
                
                else if(p.charAt(j-1) == s.charAt(i-1)||p.charAt(j-1) == '.')
                    {
                    flag[i][j]=flag[i-1][j-1];
                }
                else
                    {
                    flag[i][j]=false;
                }
            }
        }
        return flag[m-1][n-1];
    }
}