介紹

通常把確定的有窮狀態自動機(有窮狀態自動機也就是本文討論的這種狀態機)稱為DFA，把非確定的有窮狀態自動機稱為NFA。

原理

狀態機就是通過當前狀態state和事件event得到下一個狀態state，即state+event=nextstate

DFA確定性有限狀態機是有限型別的事件和狀態切換。

舉個例子，存在4個狀態，事件2個。

狀態切換圖吐下：

事件  

a       b

狀態切換
S        U       V
U        Q       V
V        U       Q
Q        Q       Q

應用

網路過濾敏感詞的常用演算法。

在編譯程式時， 詞法分析階段將原始碼中的

過濾敏感詞

在文字過濾系統中，為了能夠應付較高的併發，需要儘量減少計算。採用DFA演算法基本沒有什麼計算，基本是狀態轉移。

本例中採用多叉樹實現的有限狀態機。每個utf8編碼的中文字一般是3個字元，英文字母是一個字元。關鍵詞表則是有限狀態機的所有的狀態。輸入的句子被分成一個個字元，每個字元是一個ascii碼，範圍在0~255之間，以其為索引查詢子樹中的成員。每個子樹包含256個數組成員，即最多是256個子節點，沒有子節點的則為空。

這裡的實現查詢關鍵字不再重複查詢已查找出來的關鍵字的的部分內容作為起點的詞。

程式碼如下:

//dfa的多叉樹
#define DFA_TREE_NODE_LEN (256)
/**
 * 樹節點
 * 每個節點包含一個長度為256的陣列
 */
struct TreeNode
{
    bool end;//關鍵詞的終結
    std::vector<TreeNode*> subNodes;
    TreeNode()
    {
        end = false;
    }
    ~TreeNode()
    {
        for(oss::uint16 i = 0;i < subNodes.size();++i)
        {
            delete subNodes[i];
        }
        subNodes.clear();
    }
    /**
     * 向指定位置新增節點樹
     * @param index
     * @param node
     */
    bool setSubNode(oss::uint16 index,TreeNode* node)
    {
        if(subNodes.empty())
        {
            subNodes.resize(DFA_TREE_NODE_LEN,NULL);
        }
        if (index >= subNodes.size())
        {
            return false;
        }
        subNodes[index] = node;
        return true;
    }
    bool getSubNode(oss::uint16 index,TreeNode*& node)const
    {
        if (index >= subNodes.size())
        {
            return false;
        }
        if(!subNodes[index])
        {
            return false;
        }
        node = subNodes[index];
        return true;
    }
    bool isKeywordEnd()const
    {
        return end;
    }
    void setKeywordEnd(bool end = true)
    {
        this->end = end;
    }
};
 

class DFA
{
public:
    DFA()
    {
        rootNode = new TreeNode();
    }
    ~DFA()
    {
        delete rootNode;
    }
    /**
     * 建立DFA
     * @param keywordList
     */
    bool createKeywordTree(const std::vector<std::string> &keywordList)
    {
        //根據關鍵詞設定節點數
        for (std::vector<std::string>::const_iterator it = keywordList.begin();
                        it != keywordList.end();++it)
        {
            const std::string& keyword = *it;
            if(keyword.empty())
            {
                continue;
            }
            int keyLen = keyword.length();
            const char* bytes = keyword.data();//轉換成ASCII字元
            TreeNode* tempNode = rootNode;
            //迴圈每個位元組
            for (int i = 0; i < keyLen; i++)
            {
                int index = bytes[i] & 0xff; //字元轉換成數字，作為索引來設定節點（ASCII字元的值是0~255）
                TreeNode* node(NULL);
                if(!tempNode->getSubNode(index,node))//沒有該值的就設定
                {
                    node = new TreeNode();
                    if(!tempNode->setSubNode(index, node))
                    {
                        printf("setSubNode failed:{%s}\n", keyword.c_str());
                        return false;
                    }
                }
                tempNode = node;
                if(i == keyLen - 1)//關鍵詞結束， 設定節點樹結束標誌
                {
                    tempNode->setKeywordEnd();
//                    printf("DFA:{%s}len(%d)", keyword.c_str(),keyword.length());
                }
            }
        }
        return true;
    }
    /**
     * 搜尋關鍵字
     */
    bool searchKeyword(const std::string& tofilter,std::vector<std::string>& words)
    {
        words.clear();
        if(tofilter.empty())
        {
            return true;
        }
        bool boFound(false);
        int len = tofilter.length();
        const char* bytes = tofilter.data();//轉換成ASCII字元
        TreeNode* tempNode = rootNode;
        int rollback = 0;   //回滾數
        int position = 0;//當前比較的位置
        while (position < len)
        {
            char c = bytes[position];
            int index = c & 0xFF;
            keywordBuffer.push_back(c); //寫關鍵詞快取
            if(!tempNode->getSubNode(index,tempNode))//當前位置的匹配結束
            {
                position = position - rollback; //回退 並測試下一個位元組
                rollback = 0;//不是任何關鍵字 回退步數 置為0
                tempNode = rootNode;//狀態機復位
                keywordBuffer.clear();//清空
            }
            else if(tempNode->isKeywordEnd())//是結束點 記錄關鍵詞
            {
//                printf("Find key:{%s}", keywordBuffer.c_str());
                words.push_back(keywordBuffer);
				keywordBuffer.clear();
                rollback = 0;   //遇到結束點 回退步數 置為0(這裡不檢查關鍵字內開始的可能的另一個關鍵字)
                boFound = true;
            }
            else
            {
                rollback++; //非結束點 回退步數加1
            }
            position++;
        }
        return boFound;
    }

    bool searchKeyword(const std::string& tofilter,std::string& filtered)
    {
        filtered = tofilter;
        if(tofilter.empty())
        {
            return true;
        }
        bool boFound(false);
        int len = tofilter.length();
        const char* bytes = tofilter.data();//轉換成ASCII字元
        TreeNode* tempNode = rootNode;
        int rollback = 0;   //回滾數
        int position = 0;//當前比較的位置
        while (position < len)
        {
            char c = bytes[position];
            int index = c & 0xFF;
            keywordBuffer.push_back(c); //寫關鍵詞快取
            if(!tempNode->getSubNode(index,tempNode))//當前位置的匹配結束
            {
                position = position - rollback; //回退 並測試下一個位元組
                rollback = 0;//不是任何關鍵字 回退步數 置為0
                tempNode = rootNode;//狀態機復位
                keywordBuffer.clear();//清空
            }
            else if(tempNode->isKeywordEnd())//是結束點 記錄關鍵詞
            {
//                printf("Find key:{%s},position(%d),size(%u),filtered size(%u)",
//                                keywordBuffer.c_str(),
//                                position,keywordBuffer.size(),filtered.size());
                change(filtered,position - keywordBuffer.size() + 1,keywordBuffer.size());
				keywordBuffer.clear();
                rollback = 0;   //遇到結束點 回退步數 置為0(這裡不檢查關鍵字內開始的可能的另一個關鍵字)
                boFound = true;
            }
            else
            {
                rollback++; //非結束點 回退步數加1
            }
            position++;
        }
        return boFound;
    }
private:
    void change(std::string& filtered,int index,int size,char letter = '*')
    {
        int i = index >= 0 ?index :0;
        int l = filtered.length();
        for(;i < l && size > 0;++i,--size)
        {
            filtered[i] = letter;
        }
    }
    //根節點
    TreeNode* rootNode;
    //關鍵詞快取
    std::string keywordBuffer;
};
 

測試用例

int main()
{
    LocalFileMgr localFileMgr;
    localFileMgr.SetConfigPath("./");
    localFileMgr.Run();//這裡是讀取敏感詞檔案，不是重點，程式碼就不列出來了。敏感詞總個數為7479
    std::vector<std::string>& keywordList = localFileMgr.m_keywordList;
    if(keywordList.empty())
    {
        printf("keywordList empty\n");
        return 0;
    }
    DFA dfa;
    if(!dfa.createKeywordTree(keywordList))
    {
        printf("createKeywordTree failed\n");
        return -1;
    }
    const std::string tofilter = "av女來深圳玩，女教師出來接待";
    std::string filtered;
    printf("tofilter (%s)\n",tofilter.c_str());
    clock_t t = clock();
    int n = 1000000;
    for(int i = 0;i < 1000000;++i)
    {
        dfa.searchKeyword(tofilter,filtered);
    }
    clock_t last = clock();
    double useTime = ((last - t)* 1000) /CLOCKS_PER_SEC ;
    printf("測試敏感詞 tofilter(%s) filtered(%s),use time(%lf)ms,try num(%d)",
                        tofilter.c_str(),filtered.c_str(),useTime,n);
    return 0;
}

測試結果 ：測試過濾次數為1000000

 tofilter(av女來深圳玩，女教師出來接待) filtered(*****來深圳玩，*********出來接待),use time(2620.000000)ms,try num(1000000)

每過濾一個關鍵字大概是1.3微秒左右。

本機中分配一個std::string 變數的時間為0.2微秒。

平均過濾含1個關鍵字一個句子的並替換為*號的時間，是分配一個std::string變數花費時間的6倍到7倍左右。