正则表达式匹配

题目描述

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

设正则表达式为p,主串为s,s前面i-1个字符和p前面j-1个字符已经匹配
1.递归法
1）若p[j]不为’∗’,p[j+1]不为’∗’ ，则比较s[i]与p[j]，若s[i]==p[j]或者p[j]为’.’,将主串和模式串均像后移动一位（i+=1,j+=1)，继续比较,不相等则返回false
2)若p[j]不为’∗’，p[j+1]为’∗’,则分两种情况
1.p[j]出现一次，若s[i]==p[j]，则将主串往后移动一位（i+=1)，模式串不移动,继续比较，若不等则表示不匹配
2.p[j]不出现，将模式串后移两位（j+=2),继续比较

 bool mach(string s,string p,int i,int j)//表示s[0..i-1]与p[0..j-1]已经匹配
    {
        int len1=s.length();
        int len2=p.length();
        if(i>=len1&&j>=len2)//模式串和主串匹配成功
           return 1;
        else if(j>=len2)//正则串已经到了结尾，主串还没匹配完，return 0;
           return 0;
        else if(i>=len1)//主串匹配完成，但正则串还有字符，如果能匹配成功则必定是a*a*a*....的模式(a为不为'*'的字符)
        {
            if((len2-j)%2!=0)
               return 0;
            int k=j+1;
            while(k<len2)
            {
                if(p[k]!='*')
                   return 0;
                k+=2;
            }
            return 1;
        }
        else
        {
            if(j+1>=len2)//正则串还剩最后一个字符
            {
                return (s[i]==p[j]||p[j]=='.')&&mach(s,p,++i,++j);
            }
            else
            {
                if(p[j]!='*'&&p[j+1]!='*')
                   return (s[i]==p[j]||p[j]=='.')&&mach(s,p,++i,++j);
                if(p[j]!='*'&&p[j+1]=='*')
                    return mach(s,p,i,j+2)||((s[i]==p[j]||p[j]=='.')&&mach(s,p,++i,j));
            }
        }
        return 0;
    }

2.动态规划
设f[i][j]表示模式串s的前i个字符和正则串的前j个字符能否匹配
1.
情况一：若p[j]为普通字符，则看s[i]==p[j],若相等则看s[0…i-1]与p[0…j-1],不等则表示不匹配
情况二：若p[j]为’.’,则看s[0…i-1]与p[0…j-1]能否匹配
两种情况可合为一种
f[i][j]=f[i-1][j-1]
2.若p[j]为’*’,则分为匹配一次和匹配0次
匹配一次：若p[j-1]能和s[i-1]匹配,(即p[j-1]=s[i-1]或者p[j- 1]=’.’)，则能否匹配取决于s[0…i-1]和p[0…j]是否匹配
f[i][j]=f[i-1][j]
匹配0次：能否匹配取决于s[0…i]和p[j-2]能否匹配
f[i][j]=f[i][j-2]

 bool isMatch(string s, string p) 
    {
        int m=s.length();
        int n=p.length();
        vector<vector<bool>> f(m+1,vector<bool>(n+1));
        for(int i=0;i<=m;i++)
        {
            for(int j=0;j<=n;j++)
            {
                //空模式串和空正则串匹配，空正则串和非空模式串不匹配
                if(j==0)
                  f[i][j]=(i==0);
                else
                {
                    if(p[j-1]!='*')
                    {
                        if(i>0&&(p[j-1]=='.'||s[i-1]==p[j-1]))
                           f[i][j]=f[i-1][j-1];
                    }
                    else
                    {
                    //匹配一次和匹配0次只要其中一个能匹配则f[i][j]就为真
                        //匹配0次
                        if(j>=2)
                        {
                            f[i][j]=(f[i][j]||f[i][j-2]);
                        }
                        //匹配一次
                        if(i>=1&&j>=2&&(p[j-2]=='.'||s[i-1]==p[j-2]))
                           f[i][j]=(f[i][j]||f[i-1][j]);
                    }
                }
            }
        }
        return f[m][n];
    }