完整引擎代碼在github上，地址爲：https://github.com/sun2043430/RegularExpression_Engine.git
DFA最小化的算法原理
“DFA狀態最小化算法的工作原理是將一個DFA的狀態集合分劃成多個組，每個組中的各個狀態之間相互不可區分。然後，將每個組中的狀態合併成狀態最少DFA的一個狀態。算法在執行過程中維護了狀態集合的一個分劃，分劃中的每個組內的各個狀態不能區分，但是來自不同組的任意兩個狀態是可區分的。當任意一個組不能再被分解爲更小的組時，這個分劃就不能再進一步精化，此時我們就得到了狀態最少的DFA。”
——《編譯原理》例3.38
起始時，該分劃包含兩個組：接受狀態組和非接受狀態組。
實例
如圖
首先我們將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
