敏感詞過濾演算法

字串
多模式精確匹配（髒字/禁用語/關鍵字過濾演算法）——TTMP演算法 之實戰F模式

  字串
多模式精確匹配（髒字/禁用語搜尋演算法）——TTMP演算法 之B模式概述

字串
多模式精確匹配（髒字/禁用語搜尋演算法） 之演算法前傳II

字串
多模式精確匹配（髒字/禁用語搜尋演算法） 之演算法前傳

 

字串
多模式精確匹配（髒字/禁用語搜尋演算法）——TTMP演算法 之理論如此

 

使用DFA實現文字過濾

Dfa和文字過濾

文字過濾是一般大型網站必不可少的一個功能，而且很多文字類網站更是需要。那麼如何設計一個
高效的文字過濾系統就是非常重要的了。

文字過濾需求簡要描述：判斷集合A中哪些子集屬於集合B，拿javaeye來說，如果使用者發
表一篇文章（集合A），我們需要判斷這篇文章裡是否存在一些關鍵字是屬於集合B，B一般來說就是違禁詞列表。

看到這裡，沒有接觸過的同學可能會想到contains,正則之類的方法，但是很遺憾，這些
方法都是行不通的。唯一比較好的演算法是DFA。

一，DFA簡介：

學過編譯原理的同學們一定知道，在詞法分析階段將原始碼中的文本變成文法的集合就是通過確定有限自動機實現的。但是DFA並不只是詞法分析裡用到，DFA
的用途非常的廣泛，並不局限在電腦領域。

DFA的準系統是可以通過event和當前的state得到下一個state，即event+state=nextstate,

我們來看一張到處都能找到的狀態圖：

大寫字母是狀態，小寫字母是動作：我們可以看到S+a=U,U+a=Q,S+b=V等等。一般情況下我們可以用矩陣來表示整個狀態轉移過程：

－－－－－－－－－－－－－－－

狀態/字元  a       b

S        U       V

U        Q       V

V        U       Q

Q        Q       Q

但是表示狀態圖可以有很多資料結構，上面的矩陣只是一個便於理解的簡單例子。而接下來在本文提到的文字過濾系統中會使用另外的資料結構來實現自動
機模型

二，文字過濾

在文字過濾系統中，為了能夠應付較高的並發，有一個目標比較重要，就是盡量的減少計算，而在DFA中，基本沒有什麼計算，有的只是狀態的轉移。而
要把違禁文字列表構造成一個狀態機器，用矩陣來實現是比較麻煩的，下面介紹一種比較簡單的實現方式，就是樹結構。

所有的違禁詞其本質來說是有ascii碼組成的，而待過濾文本其本質也是ascii碼的集合，比如說：

輸入是A=[101,102,105,97,98,112,110]

違禁詞列表：

[102,105]

[98,112]

那麼我們的任務就是把上面兩個違禁詞構造成一個DFA，這樣輸入的A就可以通過在這個DFA上的轉移來實現違禁詞尋找的功能。

樹結構實現這個DFA的基於的基本方法是數組的index和數組value之間的關係（在雙數組trie中同樣是基於這一基本方法）

那麼102其實可以看作一個數組索引，而105是102這個索引指向的下一個數組中的一個索引，105後面沒有值了，那就代表這個違禁詞結束了。

通過這樣一種方式，就可以構造出一顆DFA的樹結構表示。

接著遍曆輸入文本中的每一個byte，然後在DFA中作狀態轉移就可以判斷出一個違禁詞是否出現在輸入文本中。

1. public class DFA {   
2.     private String[] arr = {"DFA", "噁心", "DA"};   
3.     private Node rootNode = new Node('R');   
4.        
5.     private String content = "Hello DFA World DFA, HaHa! 噁心";   
6.        
7.     private List<String> words = new ArrayList<String>();   
     
8.     private List<String> word = new ArrayList<String>();
     
9.     int a = 0;   
10.        
11.     private void searchWord() {   
12.         char[] chars = content.toCharArray();   
13.         Node node = rootNode;   
14.         while(a<chars.length) {   
15.             node = findNode(node,chars[a]);   
16.             if(node == null) {   
17.                 node = rootNode;   
18.                 a = a - word.size();   
19.                 word.clear();   
20.             } else if(node.flag == 1) {   
21.                 word.add(String.valueOf(chars[a]));   
22.                 StringBuffer sb = new StringBuffer();   
23.                 for(String str : word) {   
24.                     sb.append(str);   
25.                 }   
26.                 words.add(sb.toString());   
27.                 a = a - word.size() + 1;   
28.                 word.clear();   
29.                 node = rootNode;   
30.             } else {   
31.                 word.add(String.valueOf(chars[a]));   
32.             }   
33.             a++;   
34.         }   
35.     }   
36.        
37.     private void createTree() {   
38.         for(String str : arr) {   
39.             char[] chars = str.toCharArray();   
40.             if(chars.length > 0)   
41.                 insertNode(rootNode, chars, 0);   
42.         }   
43.     }   
44.        
45.     private void insertNode(Node node, char[] cs, int index) {   
46.         Node n = findNode(node, cs[index]);   
47.         if(n == null) {   
48.             n = new Node(cs[index]);   
49.             node.nodes.add(n);   
50.         }   
51.            
52.         if(index == (cs.length-1))   
53.             n.flag = 1;   
54.                
55.         index++;   
56.         if(index<cs.length)   
57.             insertNode(n, cs, index);   
58.     }   
59.        
60.     private Node findNode(Node node, char c) {   
61.         List<Node> nodes = node.nodes;   
62.         Node rn = null;   
63.         for(Node n : nodes) {   
64.             if(n.c==c) {   
65.                 rn = n;   
66.                 break;   
67.             }   
68.         }   
69.         return rn;   
70.     }   
71.        
72.     public static void main(String[] args) {   
73.         DFA dfa = new DFA();   
74.         dfa.createTree();   
75.         dfa.searchWord();   
76.         System.out.println(dfa.words);   
77.     }   
78.        
79.        
80.     private static class Node {   
81.         public char c;   
82.         public int flag; //1：表示終結，0：延續   
83.         public List<Node> nodes = new ArrayList<Node>();
      
84.            
85.         public Node(char c) {   
86.             this.c = c;   
87.             this.flag = 0;   
88.         }   
89.            
90.         public Node(char c, int flag) {   
91.             this.c = c;   
92.             this.flag = flag;   
93.         }   
94.     }   
95. }