敏感詞過濾算法

字符串 多模式精確匹配（髒字/敏感詞彙/關鍵字過濾算法）——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. }