regex -> 逆波兰表达式 -> NFA -> DFA

  1 class Solution {
  2 public:
  3 
  4     /*
  5     * 利用DFA解决leetcode 10.正则表达式 问题
  6     * 
  7     * 步骤：
  8     * 1. 将正则字符串视为后序遍历表达式，利用栈和运算符优先级转换为
  9     *    中序遍历表达式，即逆波兰表达式。
 10     * 2. 使用中序串通过Thompson算法构造NFA。
 11     * 3. 将NFA使用子集构造算法转换为DFA。
 12     * 4. 将给定串s输入DFA模拟所有状态，若出现s读取完毕且处于结束节点则返回true。
 13     * 
 14     * 注意：
 15     * 为了简单起见，所有的new都没有进行delete。
 16     * 
 17     * 参考：
 18     * 第1步可以参考台湾清华大学 韩永楷 《数据结构》课程 第7.2 - 7.3课
 19     * 第2-4步可以参考中科大 华保健 《编译原理》课程 第2.3.1 - 3.2.4课
 20     */
 21 
 22     // NFA使用的节点
 23     struct Node;
 24 
 25     // NFA使用的路径
 26     struct Path
 27     {
 28         char c;
 29         Node * dest;
 30         Path(char in_c, Node* in_dest) :c(in_c), dest(in_dest) {}
 31     };
 32 
 33     struct Node
 34     {
 35         int index;
 36         vector<Path> pathes;
 37         Node()
 38         {
 39             static int i = 0;
 40             index = i++;
 41         }
 42         Node(vector<Path> in_pathes) :pathes(in_pathes) {}
 43         void AddPath(char c, Node* dest)
 44         {
 45             pathes.emplace_back(c, dest);
 46         }
 47     };
 48 
 49     // 将后序遍历正则串转换为中序遍历
 50     // 使用建立ExpressionTree的方法
 51     // 字符连接则添加一个&作为运算符
 52     queue<char> ToInOrder(string s)
 53     {
 54         int len = s.length();
 55         queue<char> ans;
 56         stack<char> symbols; // 符号栈
 57         bool prevIsChar = false;
 58 
 59         // 将低优先级的运算符全部弹出至ans
 60         auto PopLowPriority = [&]()
 61         {
 62             while (!symbols.empty())
 63             {
 64                 ans.push(symbols.top());
 65                 symbols.pop();
 66             }
 67 
 68         };
 69 
 70         for (int i = 0; i < len; ++i)
 71         {
 72             char c = s[i];
 73             if (c == '*')
 74             {
 75                 if (!symbols.empty() && symbols.top() == '&')
 76                 {
 77                     symbols.push(c);
 78                 }
 79                 else
 80                 {
 81                     PopLowPriority();
 82                     symbols.push(c);
 83                 }
 84                 prevIsChar = true;
 85                 continue;
 86             }
 87 
 88             if (prevIsChar)
 89             {
 90                 PopLowPriority();
 91                 symbols.push('&');
 92             }
 93 
 94             ans.push(c);
 95 
 96             //
 97             if (i + 1 < len && s[i + 1] != '*')
 98                 prevIsChar = true;
 99             else
100                 prevIsChar = false;
101         }
102 
103         PopLowPriority();
104 
105         return ans;
106     }
107 
108     struct Tree
109     {
110         Node* start,*end;
111     };
112 
113     // 使用Thompson算法，将中序的串构造成NFA
114     Tree CalcInOrder(queue<char> inorder)
115     {
116         stack<Tree> temp;
117 
118         while (!inorder.empty())
119         {
120             char c = inorder.front();
121             inorder.pop();
122 
123             if (c == '*')
124             {
125                 auto &tree = temp.top();
126 
127                 Node* oldStart = tree.start;
128                 Node* oldEnd = tree.end;
129 
130                 Node* newStart = new Node;
131                 Node* newEnd = new Node;
132                 newStart->AddPath(0, oldStart);
133                 newStart->AddPath(0, newEnd);
134                 oldEnd->AddPath(0, oldStart);
135                 oldEnd->AddPath(0, newEnd);
136 
137                 tree.start = newStart;
138                 tree.end = newEnd;
139                 continue;
140             }
141 
142             if (c == '&')
143             {
144                 auto e2 = temp.top();temp.pop();
145                 auto e1 = temp.top(); temp.pop();
146 
147                 Tree tree;
148                 tree.start = e1.start;
149                 tree.end = e2.end;
150                 e1.end->AddPath(0, e2.start);
151 
152                 temp.push(tree);
153                 continue;
154             }
155 
156             Node* node1 = new Node;
157             Node* node2 = new Node;
158             node1->AddPath(c, node2);
159             temp.push({ node1,node2 });
160         }
161         return temp.top();
162     }
163 
164     // 闭包函数
165     // 返回：一个节点的闭包，即
166     //       一个节点通过ε路径能够达到的所有节点的集合（包括自身）
167     set<Node*> e_closure(Node* start)
168     {
169         set<Node*> ans;
170         queue<Node*> q;
171         q.push(start);
172         while (!q.empty())
173         {
174             auto node = q.front();
175             q.pop();
176 
177             ans.insert(node);
178 
179             for (auto& path : node->pathes)
180                 if (path.c == 0 && ans.find(path.dest) == ans.end())
181                     q.push(path.dest);
182         }
183         return ans;
184     }
185 
186     // DFA使用的节点结构
187     struct FinalNode;
188     struct FinalPath
189     {
190         char c;
191         FinalNode* dest;
192         FinalPath(char c, FinalNode* dest) :c(c), dest(dest) {}
193     };
194 
195     struct FinalNode
196     {
197         int index;
198         bool isEnd;
199         vector<FinalPath> pathes;
200         FinalNode(bool isEnd) :isEnd(isEnd)
201         {
202             static int i = 0;
203             index = i++;
204         }
205         void AddPath(char c, FinalNode *dest)
206         {
207             pathes.emplace_back(c,dest);
208         }
209     };
210 
211     using FinalTree = FinalNode*;
212 
213     // 子集构造算法 将NFA转换为DFA
214     FinalTree BuildSubSet(const Tree tree)
215     {
216         // 返回一个节点是否为end节点
217         auto IsEnd = [&](Node* node)->bool
218         {
219             return node == tree.end;
220         };
221 
222         // 返回一个集合中是否有end节点
223         auto SetIsEnd = [&](const set<Node*>& nodeSet)->bool
224         {
225             return nodeSet.find(tree.end) != nodeSet.end();
226         };
227 
228         set<Node*> q0;
229         q0 = e_closure(tree.start);
230 
231         FinalNode* n0 = new FinalNode(SetIsEnd(q0));
232         map<set<Node*>, FinalNode*> newTreeDict;
233         newTreeDict[q0] = n0;
234 
235         FinalTree newTree;
236         newTree = n0;
237 
238         set<set<Node*>> Q;
239         Q.insert(q0);
240 
241         queue<set<Node*>> worklist;
242         worklist.push(q0);
243         while (!worklist.empty())
244         {
245             auto q = worklist.front();
246             worklist.pop();
247 
248             // 
249             map<char, set<Node*>> dict;
250             for (auto node : q)
251             {
252                 for (auto& path : node->pathes)
253                 {
254                     if (path.c != 0)
255                     {
256                         dict[path.c].insert(path.dest);
257                     }
258                 }
259             }
260 
261             for (auto& pr : dict)
262             {
263                 for (auto node : pr.second)
264                 {
265                     auto t = e_closure(node);
266                     FinalNode* node_t = nullptr;
267                     if (newTreeDict.find(t) != newTreeDict.end())
268                         node_t = newTreeDict[t];
269                     else
270                     {
271                         node_t=new FinalNode(SetIsEnd(t));
272                         newTreeDict[t] = node_t;
273                     }
274 
275                     //
276                     FinalNode* node_q = newTreeDict[q];
277                     node_q->AddPath(pr.first, node_t);
278 
279                     if (Q.find(t) == Q.end())
280                     {
281                         Q.insert(t);
282                         worklist.push(t);
283                     }
284                 }
285             }
286         }
287         return newTree;
288     }
289 
290     // 遍历DFA，确定字符串是否匹配
291     bool IsMatch(string s, FinalTree dfa)
292     {
293         struct State
294         {
295             int spos; // 当前的字符串序号
296             FinalNode* node; // 当前所在的节点
297         };
298 
299         int len = s.length();
300         State state0 = { -1,dfa };
301         queue<State> q;
302         q.push(state0);
303 
304         while (!q.empty())
305         {
306             auto state = q.front();
307             q.pop();
308 
309             // 若字符串已读取到头，且当前节点为末尾，则返回true
310             if (state.spos == len-1)
311             {
312                 if (state.node->isEnd)
313                     return true;
314 
315                 // 只是字符串读到头，但节点不是尾节点
316                 continue;
317             }
318 
319             for (auto& path : state.node->pathes)
320             {
321                 // 若下一个字符 和路径匹配，或者该路径匹配一个'.'
322                 if (path.c == s[state.spos + 1] || path.c=='.')
323                 {
324                     // 加入队列
325                     q.push({ state.spos + 1,path.dest });
326                 }
327             }
328         }
329         return false;
330     }
331 
332     bool isMatch(string s, string p)
333     {
334         if (p.empty()) return s.empty();
335         auto q = ToInOrder(p);
336         auto tree = CalcInOrder(q);
337         auto DFA = BuildSubSet(tree);
338 
339         return IsMatch(s, DFA);
340     }
341 };