DFA 的化简

DFA 的化简

对于一个 NFA ,当把它确定化之后,得到的 DFA 可能含有较多的状态,还应该对其进行化简。任何正规语言都有一个唯一的状态数目最少的 DFA 。而且,对于同一个语言,可以存在多个识别该语言的 DFA 。从任意一个接受相同语言的 DFA 出发,通过分组合并等价的状态,总可以得到这个状态数最少的 DFA 。

1.DFA 的化简

所谓一个 DFA M 的化简是指寻找一个状态数比 M 少的 DFA M’ ,使得 L ( M ) = L ( M’ )。

化简了的 DFA M’ 满足两个条件:

(1 )没有多余状态。
(2 )它的状态集中,没有两个状态是互相等价的。

2. 有穷自动机的多余状态

所谓有穷自动机的多余状态是指从该自动机的开始状态出发,任何可识别的输入串也不能到达的状态。

3. 等价状态

设 DFA M = ( Q ,Σ , f , S 0 , F ), s , t ∈ Q 。若对任何 α ∈ Σ * , f ( s , α ) ∈ F 当且仅当 f ( t , α )∈ F ,则称状态 s 和 t 是等价的。如果 s 和 t 不等价,则称 s 和 t 是可区别的。例如,终态与非终态是可区别的。因为终态有一条到达自身的 ε 道路,而非终态没有到达终态的 ε 道路。

5. 化简方法

DFA M 最小化的方法是把 M 的状态集 Q 分划成一些不相交的子集,使得每个子集中任何两个状态是等价的,而任何两个属于不同子集的状态都是可区别的;然后在每个子集中任取一个状态作“代表”,而删去子集中其余状态,并把射向其余状态的箭弧都改为射向作为“代表”的状态中。

下面给出化简算法的具体执行步骤。

输入:一个 DFA M 。
输出:接受与 M 相同语言的 DFA M' ,且其状态数最少。

方法:
(1 )将 DFA M 的状态集 Q 分成两个子集:终态集 F 和非终态集 ┐ F ,形成初始分划 Π 。

(2 )对 Π 建立新的分划 Π New 。对 Π 的每个状态子集 G ,进行如下变换:
① 把 G 分划成新的子集,使得 G 的两个状态 s 和 t 属于同一子集,当且仅当对任何输入符号 a ,状态 s 和 t 转换到的状态都属于 Π 的同一子集。
② 用 G 分划出的所有新子集替换 G ,形成新的分划 Π New 。

(3 )如果 Π New = Π ,则执行第( 4 )步;否则令 Π = Π New ,重复第( 2 )步。

(4 )分划结束后,对分划中的每个状态子集,选出一个状态作代表,而删去其他一切等价的状态,并把射向其他状态的箭弧改为射向这个作为代表的状态。这样得到的 DFA M’ 是与DFA M 等价的一切 DFA 中状态数最少的 DFA 。

【例 3.16 】将图 3.14 中的 DFA 最小化。在这里插入图片描述

由图 3.14 可知,给定的 DFA 中无多余状态。将 DFA M 的状态集{ A , B , C , D , E }划分成两个子集:终态集{E }和非终态集{ A , B , C , D },形成初始分划 Π = ({ A , B , C , D },{ E })。

首先考虑子集{E },因为这一子集由一个状态组成,不能再分划,所以把{ E }作为 Π New 中的一个子集。
再考虑非终态集{A , B , C , D },这个子集中的每一个状态对于输入符号 a 都转移到状态 B ,即{A , B , C , D } a = { B } ⊂ { A , B , C , D }。但是{ A , B , C , D } b = { C , D , E },既不包含在{ E }子集中,也不包含在{A , B , C , D }子集中,也就是说,对输入符号 b ,状态 A , B , C 分别转换到同一子集{ A , B , C ,D }中的状态,而状态 D 对输入符号 b 转换到状态 E ,它是 Π 的另一个子集{ E }中的状态,所以,对子集{A , B , C , D }要进行分划,分划成两个新的子集{ A , B , C }和{ D },于是 Π New = ({ A , B , C },{D },{ E }),它不等于 Π = ({ A , B , C , D },{ E }),现以 Π New 作为 Π ,即 Π = ({ A , B , C },{ D },{ E })。

考虑子集{A , B , C },因为{ A , B , C } a = { B } ⊂ { A , B , C },而{ A , B , C } b = { C , D }既不包含在{A , B , C }子集中,也不包含在{ D }子集中,所以对子集{ A , B , C }进行分划,由于状态 A 和 C 对于输入符号 b 均转到状态 C ,而状态 B 对于输入符号 b 转到状态 D ,故应将{ A ,B , C }分划成{ A , C }及{B },从而又得到 Π New = ({ A , C },{ B },{ D },{ E }),由于此时仍然有 Π New ≠ Π ,故再以 Π New 作为 Π ,即 Π = ({ A ,C },{ B },{ D },{ E }),考察子集{ A , C },由于{ A , C } a = { B },{ A , C } b = { C } ⊂ { A , C },所以子集{A , C }不能再分划,此时 Π New = Π ,整个分划过程结束。

至此,选择 A 作为{ A , C }的代表,将状态 C 从状态转换图中删去,并将原来引向 C 的弧都引至 A ,这样得到了化简后的 DFA M’ ,如图 3.16 所示。
在这里插入图片描述

与原来的 DFA 相比,化简了的 DFA 具有较少的状态,因而计算机实现起来比较简洁。

【例 3.17 】将图 3.15 中的 DFA M 最小化。在这里插入图片描述

分析 由图 3.15 可知,给定的 DFA 无多余状态。将 DFA M 的状态集{ 0 ,1 , 2 }分成两个子集:终态集和非终态集,形成初始分划 Π = {{ 0 },{ 1 ,2 }}。

由于非终态集{0 }只有一个状态,不能再分划,对终态集{ 1 , 2 }有

{ 1 , 2 } l = { 2 } ⊂ { 1 , 2 },
{1 , 2 } d = { 2 } ⊂ { 1 , 2 },

不可再分划,取 1 作代表,化简后的 DFA 如图 3.17 所示。
在这里插入图片描述

  • 17
    点赞
  • 91
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DFA(确定有限状态自动机)的化简是将一个复杂的DFA转化为一个更简单的DFA,其实现过程主要有以下几个步骤: 1. 消除不可达状态:从起始状态出发,通过转移函数能够到达的状态称为可达状态,不能到达的状态称为不可达状态。将所有不可达状态删除。 2. 合并等价状态:将可以相互到达的状态合并为一个状态,使得新的DFA中状态数最少。通过等价关系划分算法,对状态进行分组,分组后的状态就是等价状态。 3. 构造化简后的DFA:根据等价状态分组的结果,构造化简后的DFA。 下面是Java实现DFA化简的示例代码: ```java import java.util.*; public class DFAMinimization { public static void main(String[] args) { int[][] transition = {{1,2},{2,3},{3,4},{4,5},{5,6},{6,7},{7,8},{8,9},{9,10},{10,11},{11,12},{12,13},{13,14},{14,15},{15,16},{16,17},{17,18},{18,19},{19,20},{20,21},{21,22},{22,23},{23,24},{24,25},{25,26},{26,27},{27,28},{28,29},{29,30},{30,31},{31,32},{32,33},{33,34},{34,35},{35,36},{36,37},{37,38},{38,39},{39,40},{40,41},{41,42},{42,43},{43,44},{44,45},{45,46},{46,47},{47,48},{48,49},{49,50},{50,51},{51,52},{52,53},{53,54},{54,55},{55,56},{56,57},{57,58},{58,59},{59,60},{60,61},{61,62},{62,63},{63,64},{64,65},{65,66},{66,67},{67,68},{68,69},{69,70},{70,71},{71,72},{72,73},{73,74},{74,75},{75,76},{76,77},{77,78},{78,79},{79,80},{80,81},{81,82},{82,83},{83,84},{84,85},{85,86},{86,87},{87,88},{88,89},{89,90},{90,91},{91,92},{92,93},{93,94},{94,95},{95,96},{96,97},{97,98},{98,99},{99,100},{100,100}}; int[] finalStates = {100}; DFAMinimization dfaMinimization = new DFAMinimization(); dfaMinimization.minimize(transition, finalStates); } public void minimize(int[][] transition, int[] finalStates) { int n = transition.length; int[][] partition = new int[2][n]; boolean[][] marked = new boolean[n][n]; for (int i = 0; i < n; i++) { partition[0][i] = i; for (int j = 0; j < n; j++) { marked[i][j] = finalStates[i] != finalStates[j]; } } boolean changed = true; while (changed) { changed = false; for (int i = 0; i < n; i++) { for (int j = i+1; j < n; j++) { if (!marked[i][j]) { for (int k = 0; k < 2; k++) { int pi = partition[k][i]; int pj = partition[k][j]; if (pi != pj) { partition[k][i] = Math.min(pi, pj); partition[k][j] = Math.min(pi, pj); changed = true; } } } } } for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { marked[i][j] = false; } } for (int i = 0; i < n; i++) { for (int j = i+1; j < n; j++) { if (!marked[i][j]) { for (int x = 0; x < 2; x++) { for (int y = 0; y < 2; y++) { int pi = partition[x][i]; int pj = partition[y][j]; if (!marked[pi][pj]) { for (int k = 0; k < n; k++) { int pk = transition[k][i]; int pl = transition[k][j]; if (marked[pk][pl]) { marked[pi][pj] = true; changed = true; break; } } } } } } } } } int[] map = new int[n]; Arrays.fill(map, -1); int count = 0; for (int i = 0; i < n; i++) { if (map[i] == -1) { map[i] = count++; for (int j = i+1; j < n; j++) { if (!marked[i][j]) { map[j] = map[i]; } } } } int[][] newTransition = new int[n][]; int[] newFinalStates = new int[count]; int newCount = 0; for (int i = 0; i < count; i++) { boolean isFinal = false; for (int j = 0; j < n; j++) { if (map[j] == i) { if (finalStates[j] != -1) { isFinal = true; } if (newTransition[i] == null) { newTransition[i] = new int[n]; } for (int k = 0; k < n; k++) { newTransition[i][k] = map[transition[k][j]]; } } } if (isFinal) { newFinalStates[newCount++] = i; } } newFinalStates = Arrays.copyOf(newFinalStates, newCount); System.out.println(Arrays.deepToString(newTransition)); System.out.println(Arrays.toString(newFinalStates)); } } ``` 以上代码实现了DFA化简,其中transition数组表示状态转移矩阵,finalStates数组表示终止状态集合。具体实现过程中,使用等价关系划分算法对状态进行分组,最终得到化简后的DFA状态转移矩阵和终止状态集合。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值