leetcode10.正则表达式匹配不调库函数原理性解法 C++ 有限状态机模拟编译原理词法分析

最新推荐文章于 2022-09-26 20:35:21 发布

Komorebi_Liao

最新推荐文章于 2022-09-26 20:35:21 发布

阅读量216

点赞数

分类专栏：刷点题文章标签： c++ nfa 有限状态机正则表达式 leetcode

本文链接：https://blog.csdn.net/HzauTriste/article/details/108212002

版权

刷点题专栏收录该内容

22 篇文章 0 订阅

订阅专栏

直接模拟有限状态机写的，能过，但是效率不高，纯属为了写原理。

前置知识：有限状态机，《编译原理》词法分析一章中正规式转NFA方法。

题目：

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符 ‘*’ 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。

说明:

s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例 1:

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

示例 2:

输入: s = “aa” p = “a*” 输出: true 解释: 因为 ‘*’ 代表可以匹配零个或多个前面的那一个元素,
在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。

示例 3:

输入: s = “ab” p = “." 输出: true 解释: ".” 表示可匹配零个或多个（’*’）任意字符（’.’）。

示例 4:

输入: s = “aab” p = “cab” 输出: true 解释: 因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个,
‘a’ 被重复一次。因此可以匹配字符串 “aab”。

示例 5:

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

解题思路
模拟一个有限状态机即可，不懂得可以看《编译原理》词法分析一章，懂了词法分析，这个肯定能懂。
需要注意的是：因为这个有*，所以模拟出来的是NFA，不是DFA，所以跳转结果是一个数组而不止是一个整数。
也可以转换成DFA，但是没必要，NFA确定化这个过程挺不好写的。
代码中有注释，提示了总体步骤。
实现过程还是写的比较糙，很多重用部分可以改成函数的。

（这段时间刚开始刷leetcode，感觉那些操作系统，编译原理，甚至计网等课程里学的一些看似无聊的算法能用在很多题上。算法博大精深啊！来自一个准大四明年毕业后没导师要就没书读的小码虫的感概）

代码

class Solution {
    
struct Node   //状态集合
{
    vector<int> data;
    Node(int a){
        data.push_back(a);

    }
};
public:
    
bool isMatch(string s, string p) {
       int plen = p.size();
        vector<vector<Node>> dfa (plen+1,vector<Node>(27,-1));  //状态转换矩阵 第二维是dfa弧上字符，0-25为a-z，26为空字符
        if(plen == 0)
        {
            if(s.size() == 0)
            {
                return true;
            }
            else{
                return false;
            }
        }
        if(s.size() == 0)
        {

            s= "{";    //z后面一个  用来使得s[i] == 26 判断空字符
        }
        int ppos=0;
        //构建nfa
        int cur=0;//当前状态
        int last = 0;  //终态
        while(ppos<plen)
        {
            if(p[ppos] == '.')
            {
                if( (ppos+1) < plen && p[ppos+1] == '*' )
                {
                    dfa[cur][26].data.push_back(cur+1); //识别空字符
                    for(int i=0;i<26;i++)
                    {
                        dfa[cur+1][i].data.push_back(cur+1);
                    }
                    ppos +=2;
                    cur++;
                }
                else
                {
                    for(int i=0;i<26;i++)
                    {
                        dfa[cur][i].data.push_back(cur+1);
                    }
                    ppos++;
                    cur++;

                }
            }
            else if( p[ppos]<='z' && p[ppos]>= 'a' )
            {
                if( (ppos+1) < plen && p[ppos+1] == '*' )
                {

                  dfa[cur][26].data.push_back(cur+1); //识别空字符

                    dfa[cur+1][ p[ppos] - 'a'  ].data.push_back(cur+1);
                    ppos +=2;
                    cur++;
                }
                else
                {

                    dfa[cur][ p[ppos] - 'a'  ].data.push_back(cur+1);
                    ppos++;
                    cur++;

                }
            }
            last++;
        }

        vector<int> t;  //当前可能的状态
        t.push_back(0);  //初始状态
        for(int i=0;i<s.size();i++)
        {
            if(t.size() == 0)
            {
                return false;
            }



            char te = s[i];   //当前字符
//            cout<<"te:"<<te<<endl;
            vector<int> t2 ;
            //闭包运算,t闭包，结果放t
            int bf=1;
            while(bf)
            {
                bf = 0;
                int tlen = t.size();
                for(int k1=0;k1<t.size();k1++)
                {
                    int t1 = t[k1];
                    int f = 1;
                    for(int j=0;j<t2.size();j++)  //去重
                    {
                        if(t2[j] == t1)
                        {
                            f = 0;
                            break;
                        }
                    }
                    if(f)
                    {
//                        cout<<f<<"->"<<t3<<endl;
                        t2.push_back(t1);

                    }

                    for(int kk=0;kk<dfa[t1][26].data.size();kk++)
                    {
                        int t3 = dfa[t1][26].data[kk] ;
                        if(t3 != -1  )
                        {
                            int f = 1;
                            for(int j=0;j<t2.size();j++)  //去重
                            {
                                if(t2[j] == t3)
                                {
                                    f = 0;
                                    break;
                                }
                            }
                            if(f)
                            {
//                                cout<<f<<"->"<<t3<<endl;
                                t2.push_back(t3 );
                                bf = 1;
                            }

                        }
                    }
                }
                t = t2;

            }


            //走一条te弧
            t2.clear();
            for(int i=0;i<t.size();i++)
            {
                int t1 = t[i];  //现状态

                for(int kk=0;kk<dfa[t1][te-'a'].data.size();kk++)
                {
                    int t3 = dfa[t1][ te-'a' ].data[kk];

                    if(t3 != -1  )
                    {
                        int f = 1;
                        for(int j=0;j<t2.size();j++)  //去重
                        {
                            if(t2[j] == t3)
                            {
                                f = 0;
                                break;
                            }
                        }
                        if(f)
                        {
                            t2.push_back(t3 );
                        }

                    }
                }

            }

            t = t2;
            t2.clear();

           //闭包运算,t闭包，结果放t
            bf=1;
            while(bf)
            {
                bf = 0;
                int tlen = t.size();
                for(int k1=0;k1<t.size();k1++)
                {
                    int t1 = t[k1];
                    int f = 1;
                    for(int j=0;j<t2.size();j++)  //去重
                    {
                        if(t2[j] == t1)
                        {
                            f = 0;
                            break;
                        }
                    }
                    if(f)
                    {
//                        cout<<f<<"->"<<t3<<endl;
                        t2.push_back(t1);

                    }

                    for(int kk=0;kk<dfa[t1][26].data.size();kk++)
                    {
                        int t3 = dfa[t1][26].data[kk] ;
                        if(t3 != -1  )
                        {
                            int f = 1;
                            for(int j=0;j<t2.size();j++)  //去重
                            {
                                if(t2[j] == t3)
                                {
                                    f = 0;
                                    break;
                                }
                            }
                            if(f)
                            {
//                                cout<<f<<"->"<<t3<<endl;
                                t2.push_back(t3 );
                                bf = 1;
                            }

                        }
                    }
                }
                t = t2;

            }

        }

        for(int i=0;i<t.size();i++)
        {
            if(t[i] == last)
            {
                return true;
            }
        }
        return false;
    }

};

Komorebi_Liao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode10.正则表达式匹配不调库函数原理性解法 C++ 有限状态机模拟编译原理词法分析

直接模拟有限状态机写的，能过，但是效率不高，纯属为了写原理。前置知识：有限状态机，《编译原理》词法分析一章中正规式转NFA方法。题目：给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。‘.’ 匹配任意单个字符 ‘*’ 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。说明:s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。示例 1:输
复制链接

扫一扫