2021-09-26 《编译原理》学习笔记：第3周

3.6.3 ε - 闭包的计算

（1）深度优先

set closure = {};                   // 集合，最初为空

void eps_closure(x) {
    closure += {x};                 // 加入 x 
    foreach (y : x -- eps --> y)    // 对所有的 y，如果有 x 经过 eps 指向 y
        if (!visited(y))
            eps_closure(y);
}

（2）广度优先

set closure = {};
Q = [];      // 队列

void eps_closure(x) {
    Q = [x];
    while (I not empty) {
        q = deQueue(Q);                // q 出队
        closure += q;                  // 加入 q
        foreach (y : q -- eps --> y)
            if (!visited(y))
                enQueue(Q, y);         // 没有访问过，则进队列
    }
}

3.6.4 闭包的两种计算方式

1. 在线方式

   在算法计算的过程中，遇到需要计算某个结点的 ε - 闭包的时候，临时计算。

   • 缺点：效率低，可能重复求闭包。

2. 离线方式

   在算法执行之前，把 NFA 中所有结点的 ε - 闭包都计算完；这样算法开始执行后可随时使用。

   • 缺点：需要把所有结点的 ε - 闭包都计算出来，空间消耗大，利用率低。

3.7 DFA 的最小化（Hopcrofe 算法）

3.7.1 算法思想

​ 对于以下的 DFA，考虑接受状态之间、非接受状态之间是否可以合并：

1. q2 与 q3 合并：

2. q1 与 q4 合并：

3.7.2 等价类

（1）等价类

​ 对于以下状态集合：

​ 将 q1、q2 分为一类，q3 分为一类：

​ 使得：（等价类的判断标志）

1. 身为等价类的两个状态同为接受状态（终止状态）或非接受状态
2. 对每一个输入符号，等价类中的所有状态都转换到相同的等价的状态中

（2）算法

1. split(S)

   void split(S) {                       // S：状态集合
       foreach(character c)
           if (c can split S)
               split S into T1, ..., Tk  // Tk 必须是真子集
   }
   

2. hopcroft()

   void hopcroft() {
       split all nodes into N, A         // N：非接受状态  A：接受状态
       while (set is still changes)      // 如果集合仍然在切分
           split(S)                      // 对每个等价类集合调用 split
   }
   

3.7.3 示例

（1）示例 1

​ 对于字符 b：没有转换出这个集合的边，无法区分出 q1、q2、q3 三个状态；

​ 对于字符 c：同理。

（2）示例 2

1. 对于集合 A，q3 和 q5 两个状态都不接受任何的字符，也不转移，所以不可分
2. 对于集合 N，当循环到字符 e 的时候，e 导致 q2 和 q4 都发生了转换到 A，而 q0 和 q1 没有接受 e 转换到 A
3. 对于集合 {q2, q4}，都是接收 e 转移到{q3, q5}这个集合，该集合没法继续划分了
4. 对于集合{q0, q1} ，q1 接收 e 和 i 后会转移到 S，将{q0, q1}拆分成{q0}, {q1}两个集合

3.8 将 DFA 转换为可执行代码

3.8.1 DFA 的代码表示

​ 概念上讲，DFA 是一个有向图，其代码表示有以下几种：

• 转移表（邻接矩阵）
• 哈希表
• 跳转表

3.8.2 转移表

3.8.3 驱动代码

​ 驱动代码负责读从文本文件进来的输入，根据转移表中相应的表项做相应的控制，来回答给定的输入是否能被 DFA 接受。

nextToken() {
    state = 0;                    // 当前状态 s0
    stack = [];                   // 栈，用来实现最长匹配
    while (state != ERROR) {
        c = getchar();
        if (state == ACCEPT)
            clear(stack);         // 如果状态可接受，清空栈
        push(state);              // 再把当前状态压入栈
        state = table[state][c];  // 记录转移表
    }
    
    while (state != ACCEPT) {     // 如果状态一直不可接受，一直弹出，直到可接受并返回
        state = pop();            // 弹出可接受状态
        rollback();               // 回退指针
    }
}

• 如果 s 是接受状态，识别单词并向调用过程返回一个词素等；
• 如果s不是接受状态，判断在通往 s 的路径上，是否遇到过接受状态；
  • 如果有，应该将其内部状态和输入流都回滚到该点，报告成功；
  • 如果没有，报告失败