《算法》第五章部分程序 part 6

▶ 书中第五章部分程序，包括在加上自己补充的代码，非确定性有穷自动机（NFA），grep 命令（利用 NFA 匹配）

● 非确定性有穷自动机（NFA）

 package package01;

 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.Bag;
 import edu.princeton.cs.algs4.Stack;
 import edu.princeton.cs.algs4.Digraph;
 import edu.princeton.cs.algs4.DirectedDFS;

 public class class01
 {

     private Digraph graph;     // 含 ε-转移 的有穷自动机图
     private String regexp;     // 输入的正则表达式
     private final int m;       // 正则表达式包含的字符数

     public class01(String inputRegexp)                             // 根据正则表达式构造 NFA
     {
         regexp = inputRegexp;
         m = regexp.length();
         Stack<Integer> ops = new Stack<Integer>();
         graph = new Digraph(m + 1);                                 // 自动机的状态数比正则表达式多 1
         for (int i = 0; i < m; i++)
         {
             int lp = i;                                             // 指向当前操作数
             if (regexp.charAt(i) == '(' || regexp.charAt(i) == '|') // 遇到 '(' 和 '|'，压栈
                 ops.push(i);
             else if (regexp.charAt(i) == ')')                       // 遇到 ')'，吐栈
             {
                 int or = ops.pop();
                 if (regexp.charAt(or ) == '|')                      // 吐出'|'，需要添加两条边，设原文为 (A|B)
                 {
                     lp = ops.pop();                                 // 取出在此之前的 '('
                     graph.addEdge(lp, or +1);                       // 第一条边从 '(' 指向 '|' 的后一节点，表示支路 B
                     graph.addEdge(or , i);                          // 第二条边从 '|' 指向 ')' 之后，表示支路 A
                 }
                 else if (regexp.charAt(or ) == '(')                 // 吐出 '('，说明存在一个整体'(...)'，用 lp 标记起点，服务于后边的 '*'
                     lp = or ;
                 else
                     assert false;                                   // 栈顶是其他东西（遇不到该分支？因为没有把其他东西压入栈中）
             }
             if (i < m - 1 && regexp.charAt(i + 1) == '*')           // 下一个字符是闭包，需要添加两条边
             {
                 graph.addEdge(lp, i + 1);                           // 第一条边从当前节点指向 '*' 节点
                 graph.addEdge(i + 1, lp);                           // 第二条边从 '*' 节点指向当前节点，如果当前节点是 ')'，则指向当前整体的起点处
             }
             if (regexp.charAt(i) == '(' || regexp.charAt(i) == '*' || regexp.charAt(i) == ')')  // 如果当前符号是'(*)' 三者之一，则添加添加一条正常边指向下一节点
                 graph.addEdge(i, i + 1);
         }
         if (ops.size() != 0)
             throw new IllegalArgumentException("Invalid regular expression");
     }

     public boolean recognizes(String txt)               // 使用生成的 NFA 识别输入的字符串
     {
         Bag<Integer> pc = new Bag<Integer>();           // 存放当前能够到达的所有节点
         DirectedDFS dfs = new DirectedDFS(graph, 0);    // 从节点 0 深度优先遍历，表示读取正文第 0 位之前就能通过 ε-转移 到达的所有状态，放入背包 pc 中
         for (int v = 0; v < graph.V(); v++)
         {
             if (dfs.marked(v))
                 pc.add(v);
         }
         for (int i = 0; i < txt.length(); i++)          // 循环每次取原文的一个字符
         {
             if (txt.charAt(i) == '*' || txt.charAt(i) == '|' || txt.charAt(i) == '(' || txt.charAt(i) == ')')   // 被匹配的原文不能包含 '(*|)'
                 throw new IllegalArgumentException("text contains the metacharacter '" + txt.charAt(i) + "'");
             Bag<Integer> match = new Bag<Integer>();    // 临时背包，用于存放能与 txt[i] 匹配的所有正则表达式的状态（“状态” 指的是节点编号）
             for (int v : pc)                            // 遍历 pc，即以当前能够到达的所有状态为起点尝试匹配 txt[i]
             {
                 if (v == m)                             // pc 包含节点 m，说明已经到达了终点，完成匹配
                     continue;
                 if ((regexp.charAt(v) == txt.charAt(i)) || regexp.charAt(v) == '.') // txt[i] 与正则表达式当前的某个状态可以匹配，向 match 中写入 v 的下一节点
                     match.add(v + 1);
             }
             dfs = new DirectedDFS(graph, match);        // 以 match 所有元素为起点深度优先遍历，表示当前所有可达节点通过 ε-转移 到达的所有状态
             pc = new Bag<Integer>();                    // 更新 pc
             for (int v = 0; v < graph.V(); v++)
             {
                 if (dfs.marked(v))
                     pc.add(v);
             }
             if (pc.size() == 0)                         // pc 空，说明没有任何可达状态了，停止匹配
                 return false;
         }
         for (int v : pc)                                // 遍历 pc，如果包含节点 m，说明到达了终点，完成匹配
         {
             if (v == m)
                 return true;
         }
         return false;
     }

     public static void main(String[] args)
     {
         String regexp = "(" + args[0] + ")", txt = args[1]; // 输入的正则表达式最外层用括号包住
         class01 nfa = new class01(regexp);
         StdOut.println(nfa.recognizes(txt));
     }
 }

● grep 命令实现

 package package01;

 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.NFA;

 public class class01
 {
     private class01() {}

     public static void main(String[] args)
     {
         String regexp = "(.*" + args[0] + ".*)";
         for (NFA nfa = new NFA(regexp); StdIn.hasNextLine();)
         {
             String line = StdIn.readLine();
             if (nfa.recognizes(line))
                 StdOut.println(line);
         }
     }
 }