正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——5 DFA最小化
2014-05-30 09:20
676 查看
分类: C++ 算法 编译原理2013-07-18
23:39 421人阅读 评论(0) 收藏 举报
正则表达式编译原理DFA优化
目录(?)[+]
——《编译原理》例3.38
起始时,该分划包含两个组:接受状态组和非接受状态组。
![](http://img.blog.csdn.net/20130718204019312?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VuMjA0MzQzMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
(编译原理
图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的转换表为:
![](http://img.blog.csdn.net/20130718214139593?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VuMjA0MzQzMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
plaincopyprint?
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
23:39 421人阅读 评论(0) 收藏 举报
正则表达式编译原理DFA优化
目录(?)[+]
完整引擎代码在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的转换表为:
代码实现(关键代码)
[cpp] viewplaincopyprint?
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
相关文章推荐
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——5 DFA最小化
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——5 DFA最小化
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——1 概述
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——2 构造抽象语法树
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——3 计算4个函数
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——1 概述
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——3 计算4个函数
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——4 构造DFA
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——2 构造抽象语法树
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——1 概述
- 正则表达式引擎的构建——基于编译原理DFA(龙书第三章)——2 构造抽象语法树
- 编译原理中正则表达式直接构造DFA,DFA的最小化算法
- [编译原理代码][NFA转DFA并最小化DFA并使用DFA进行词法分析]
- 编译原理,确定有穷自动机DFA最小化
- 编译原理中正则表达式直接构造DFA,DFA的最小化算法
- 编译原理(二) NFA的确定化及DFA的最小化的算法及C++实现
- ASP.NET MVC的Razor引擎:View编译原理
- 【编译原理】第三章 词法分析
- “基于 Apache Mahout 构建社会化推荐引擎”一文例子运行纪实(引用)
- 基于 Apache Mahout 构建社会化推荐引擎(转载)