正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——5 DFA最小化

本文介绍DFA状态最小化算法的基本原理与实现过程,并通过具体实例详细展示如何通过算法减少DFA状态数量,提高效率。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

完整引擎代码在github上,地址为:https://github.com/sun2043430/RegularExpression_Engine.git


DFA最小化的算法原理

“DFA状态最小化算法的工作原理是将一个DFA的状态集合分划成多个组,每个组中的各个状态之间相互不可区分。然后,将每个组中的状态合并成状态最少DFA的一个状态。算法在执行过程中维护了状态集合的一个分划,分划中的每个组内的各个状态不能区分,但是来自不同组的任意两个状态是可区分的。当任意一个组不能再被分解为更小的组时,这个分划就不能再进一步精化,此时我们就得到了状态最少的DFA。”

                  ——《编译原理》例3.38

起始时,该分划包含两个组:接受状态组和非接受状态组。


实例

如图(编译原理 图3-36)

首先我们将ABCDE分划到两个组中{ABCD}和{E},{E}是接受状态组,且不可被再分割。

{ABCD}是可分割的,所以我们考虑所有可能的转换。

先看转换字符a:

A->a->B

B->a->B

C->a->B

D->a->B

所以ABCD经过a到达的集合是{B},而{B}属于{ABCD}这一个集合,所以我们说{ABCD}在输入字符为a时是不可分划的。

在来看转换字符b:

A->b->C

B->b->D

C->b->C

D->b->E

到达的集合是{CDE},其中CD属于{ABCD}分划,E属于{E}分划。

所以我们说{ABCD}在输入字符为b时是可分划的。按照输入b转换到的组,我们将{ABCD}分划为{ABC}和{D}两个组。同时将{ABCD}从组集合中删除。因为{ABCD}已经分划为{ABC}和{D}。

接下来看{ABC},先看在字符a上的转换:

A->a->B

B->a->B

C->a->B

因为全部都是到达的B,所以不可分划。

再看在字符b上的转换:

A->b->C

B->b->D

C->b->C

其中C属于{ABC}组,D属于{D}组。所以{ABC}可以分划为{AC}和{B}。

最后看{AC}组,A和C在字符a上都转换到B,在字符b上都转换到C,所以{AC}是不可分划的组。

最后得到的分组情况为:

{AC},{B},{D},{E}。

同一个组中只需要保留一个节点即可(因为同一个组的节点在转换上都是相同的),所以我们直接将C节点去除,保留A节点(因为A节点是开始状态节点)。最终得到的状态最小DFA的转换表为:


代码实现(关键代码)

BOOL CDFA::FindRelationNode(list<DFANodeRelation> &lstNodeRelation, 
                            int nIdxFrom, unsigned char ch, int &nMapToIdx)
{
    list<DFANodeRelation>::iterator it = lstNodeRelation.begin();
    for ( ; it != lstNodeRelation.end(); it++)
    {
        if (it->m_nIdxFrom == nIdxFrom && it->m_ch == ch)
        {
            nMapToIdx = it->m_nIdxTo;
            return TRUE;
        }
    }
    return FALSE;
}

int CDFA::FindIdxInListSet(int nMapToIdx, list<set<int>> &lstSet)
{
    int i = 0;
    for (list<set<int>>::iterator it = lstSet.begin(); it != lstSet.end(); it++, i++)
    {
        set<int> & setIdx = *it;
        for (set<int>::iterator itInt = setIdx.begin(); itInt != setIdx.end(); itInt++)
        {
            if (nMapToIdx == *itInt)
            {
                return i;
            }
        }
    }
    return -1;
}

BOOL CDFA::PartitionOneGroup(list<set<int>> &lstSet, set<int> &setOneGroup, 
                             list<DFANodeRelation> &lstNodeRelation, 
                             map<int, set<int>> &mapPartitionInfo)
{
    BOOL            bRet            = FALSE;
    list<DFANodeRelation>::iterator itRelation;
    set<unsigned char>              setChar;
    set<int>                        setMapToIdx;

    try
    {
        // collect each node's translation char in the set
        for (set<int>::iterator it = setOneGroup.begin(); it != setOneGroup.end(); it++)
        {
            for (itRelation = lstNodeRelation.begin(); itRelation != lstNodeRelation.end(); itRelation++)
            {
                if (itRelation->m_nIdxFrom == *it)
                {
                    setChar.insert(itRelation->m_ch);
                }
            }
        }
        // end collect

        for (set<unsigned char>::iterator it = setChar.begin(); it != setChar.end(); it++)
        {
            mapPartitionInfo.clear();
            int nMapToIdx = -1; // indicate map to a dead state, there no translation for this pair of node/char
            for (set<int>::iterator itNodeId = setOneGroup.begin(); itNodeId != setOneGroup.end(); itNodeId++)
            {
                if (FindRelationNode(lstNodeRelation, *itNodeId, *it, nMapToIdx))
                {
                    int nIdx = FindIdxInListSet(nMapToIdx, lstSet);
                    if (nIdx == -1)
                        assert(FALSE);
                    mapPartitionInfo[nIdx].insert(*itNodeId);
                }
                else
                    mapPartitionInfo[-1].insert(*itNodeId);
            }
            if (mapPartitionInfo.size() > 1)// had distinguish
            {
                break;
            }
        }
    }
    catch (...)
    {
        goto Exit0;
    }

    bRet = TRUE;
Exit0:
    return bRet;
}

BOOL CDFA::PartitionGroups(list<set<int>> &lstSet, list<DFANodeRelation> &lstNodeRelation)
{
    BOOL                        bRet   = FALSE;
    list<set<int>>::iterator    it     = lstSet.begin();
    map<int, set<int>>          mapPartitionInfo;
    //  used map to record the node can translate to which group, 
    // the int(map key) is group id.
    // the set<int> contain the node ID that can translate to the group.

    for ( ; it != lstSet.end(); )
    {
        mapPartitionInfo.clear();
        set<int> &setOneGroup = *it;
        CHECK_BOOL ( PartitionOneGroup(lstSet, setOneGroup, lstNodeRelation, mapPartitionInfo) );
        if (mapPartitionInfo.size() > 1)// means that current group can partition
        {
            map<int, set<int>>::iterator itM = mapPartitionInfo.begin();
            for ( ; itM != mapPartitionInfo.end(); itM++)
            {
                try
                {
                    lstSet.push_back(itM->second);
                }
                catch (...)
                {
                    goto Exit0;
                }
            }
            it = lstSet.erase(it);// if a group had partition, the group need delete in the list

        }
        else
             it++;
    }

    bRet = TRUE;
Exit0:
    return bRet;
}

/**
    @brief     Minimize DFA
    @param     nSetSize            node count 
    @param     lstNodeRelation     node relation table
    @param     setAcceptingIdx     set for Accepting status node's index
    @param     lstSet              for save the result
    @return    TRUE, success; otherwise means fail.
*/
BOOL CDFA::MinimizeDFA(int                     nNodeCount,
                       list<DFANodeRelation>   &lstNodeRelation,
                       set<int>                &setAcceptingIdx,
                       list<set<int>>          &lstSet
)
{
    BOOL            bRet            = FALSE;
    set<int>        setUnAccepting;

    assert(nNodeCount >= 1);
    assert(setAcceptingIdx.size() != 0);
    assert(lstNodeRelation.size() != 0);

    lstSet.clear();

    try 
    {
        lstSet.push_back(setAcceptingIdx);

        // get unAccepting set
        for (int i = 0; i < nNodeCount; i++)
        {
            if (setAcceptingIdx.find(i) == setAcceptingIdx.end())
            {
                setUnAccepting.insert(i);
            }
        }
        if (setUnAccepting.size() > 0)
        {
            lstSet.push_back(setUnAccepting);
        }
    }
    catch (...)
    {
        goto Exit0;
    }

    CHECK_BOOL ( PartitionGroups(lstSet, lstNodeRelation) );

    bRet = TRUE;
Exit0:
    
    return bRet;
}

完整引擎 代码在github上,地址为: https://github.com/sun2043430/RegularExpression_Engine.git

1. 实验内容 每一个正规集都可以由一个状态数最少的DFA所识别,这个DFA是唯一的(不考虑同构的情况)。任意给定的一个DFA,根据以下算法设计一个C程序,将该DFA 化简为与之等价的最简DFA。 2. 实验设计分析 2.1 实验设计思路 根据实验指导本上的相关知识,实现算法。 2.2 实验算法 (1)构造具有两个组的状态集合的初始划分I:接受状态组 F 和非接受状态组 Non-F。 (2)对I采用下面所述的过程来构造新的划分I-new. For I 中每个组G do Begin 当且仅当对任意输入符号a,状态s和读入a后转换到I的同一组中; /*最坏情况下,一个状态就可能成为一个组*/ 用所有新形成的小组集代替I-new中的G; end (3)如果I-new=I,令I-final=I,再执行第(4)步,否则令I=I=new,重复步骤(2)。 (4)在划分I-final的每个状态组中选一个状态作为该组的代表。这些代表构成了化简后的DFA M'状态。令s是一个代表状态,而且假设:在DFA M中,输入为a时有从s到t转换。令t所在组的代表是r,那么在M’中有一个从s到r的转换,标记为a。令包含s0的状态组的代表是M’的开始状态,并令M’的接受状态是那些属于F的状态所在组的代表。注意,I-final的每个组或者仅含F中的状态,或者不含F中的状态。 (5)如果M’含有死状态(即一个对所有输入符号都有刀自身的转换的非接受状态d),则从M’中去掉它;删除从开始状态不可到达的状态;取消从任何其他状态到死状态的转换。 。。。。。。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值