利用子集法实现NFA到DFA的转换_nfa实现dfa转换python-CSDN博客

本文链接：https://blog.csdn.net/MX_1122/article/details/138855388

一、目的要求：

理解子集法的两个运算；
能够应用合理的数据结构表示状态转换图。

二、实验内容：

基于课堂讲解的子集法算法，编写程序实现任意NFA到DFA的转换。
1、设计合理的数据结构表示有限自动机；
2、输出转换后的DFA对应的5个元组；
3、画出DFA;

完整代码

import graphviz  # 导入图形化工具库

class NFA:
    def __init__(self, states, alphabet, transitions, start_state, accept_states):
        self.states = states  # NFA 的状态集合。
        self.alphabet = alphabet  # 输入符号的集合。
        self.transitions = transitions  # 状态转移函数，使用字典表示，键是 (state, symbol) 对，值是状态集合。
        self.start_state = start_state  # 起始状态。
        self.accept_states = accept_states  # 接受状态的集合。

    # 判断状态是否为接受状态 终态
    def is_accept_state(self, state):
        return state in self.accept_states

    # 计算给定状态集合的epsilon闭包
    def epsilon_closure(self, states):
        closure = set(states)
        queue = list(states)
        while queue:
            current_state = queue.pop(0)
            epsilon_transitions = self.transitions.get((current_state, None), set())
            for state in epsilon_transitions:
                if state not in closure:
                    closure.add(state)
                    queue.append(state)
        return frozenset(closure)

    # 计算给定状态集合通过某个符号的转移后的状态集合
    def move(self, states, symbol):
        move_states = set()
        for state in states:
            move_states.update(self.transitions.get((state, symbol), set()))
        return self.epsilon_closure(move_states)

def nfa_to_dfa(nfa):
    dfa_states = set()
    dfa_transitions = {}
    dfa_start_state = nfa.epsilon_closure({nfa.start_state})
    dfa_accept_states = set()
    queue = [dfa_start_state]
    visited = set()

    while queue:
        current_states = queue.pop(0)
        dfa_states.add(current_states)
        visited.add(current_states)

        if nfa.is_accept_state(current_states):
            dfa_accept_states.add(current_states)

        for symbol in nfa.alphabet:
            next_states = nfa.move(current_states, symbol)
            dfa_transitions[(current_states, symbol)] = next_states
            if next_states not in visited:
                queue.append(next_states)

    return dfa_states, nfa.alphabet, dfa_transitions, dfa_start_state, dfa_accept_states

# 生成DFA的可视化图
def draw_dfa(dfa):
    dfa_states, alphabet, transitions, start_state, accept_states = dfa
    dot = graphviz.Digraph()
    dot.attr(rankdir='LR')  # 设置图的方向为从左到右

    # 添加状态节点
    for state in dfa_states:
        state_label = ','.join(sorted(state))  # 将状态集合转换为逗号分隔的字符串
        if state in accept_states:
            dot.node(state_label, shape='doublecircle')  # 接受状态用双圆圈表示
        else:
            dot.node(state_label, shape='circle')

    # 添加起始状态
    start_state_label = ','.join(sorted(start_state))
    dot.node("start", shape='point')  # 设置起始状态节点形状为点
    dot.edge("start", start_state_label)  # 添加从起始状态到第一个状态的边

    # 添加状态转移边
    for (current_state, symbol), next_state in transitions.items():
        current_state_label = ','.join(sorted(current_state))
        next_state_label = ','.join(sorted(next_state))
        dot.edge(current_state_label, next_state_label, label=symbol)  # 添加状态转移边

    dot.render('dfa', format='png', cleanup=True)  # 生成DFA的图像并保存为png格式

# 定义NFA
nfa = NFA(
    states={'q0', 'q1', 'q2'},
    alphabet={'a', 'b'},
    transitions={
        ('q0', 'a'): {'q0', 'q1'},
        ('q1', 'b'): {'q2'},
        ('q2', None): {'q1'}
    },
    start_state='q0',
    accept_states={'q2'}
)

# 将NFA转换为DFA并绘制DFA的图像
dfa = nfa_to_dfa(nfa)
draw_dfa(dfa)

完成后生成图片
在这里插入图片描述

代码详解

NFA 类

class NFA:
    def __init__(self, states, alphabet, transitions, start_state, accept_states):
        self.states = states
        self.alphabet = alphabet
        self.transitions = transitions
        self.start_state = start_state
        self.accept_states = accept_states

states：NFA 的状态集合。
alphabet：输入符号的集合。
transitions：状态转移函数，使用字典表示，键是 (state, symbol) 对，值是状态集合。
start_state：起始状态。
accept_states：接受状态的集合。

    def is_accept_state(self, state):
        return state in self.accept_states

is_accept_state 方法：检查给定的状态是否是接受状态(终态)。

    def epsilon_closure(self, states):
        closure = set(states)
        queue = list(states)
        while queue:
            current_state = queue.pop(0)
            epsilon_transitions = self.transitions.get((current_state, None), set())
            for state in epsilon_transitions:
                if state not in closure:
                    closure.add(state)
                    queue.append(state)
        return frozenset(closure)

epsilon_closure 方法：计算给定状态集合的 epsilon-闭包（即通过 epsilon 转移可以到达的所有状态）。

    def move(self, states, symbol):
        move_states = set()
        for state in states:
            move_states.update(self.transitions.get((state, symbol), set()))
        return self.epsilon_closure(move_states)

move 方法：计算给定状态集合通过某个输入符号转移后的状态集合，返回转移后状态的 epsilon-闭包。

NFA 转换为 DFA

def nfa_to_dfa(nfa):
    dfa_states = set()
    dfa_transitions = {}
    dfa_start_state = nfa.epsilon_closure({nfa.start_state})
    dfa_accept_states = set()
    queue = [dfa_start_state]
    visited = set()

    while queue:
        current_states = queue.pop(0)
        dfa_states.add(current_states)
        visited.add(current_states)

        if nfa.is_accept_state(current_states):
            dfa_accept_states.add(current_states)

        for symbol in nfa.alphabet:
            next_states = nfa.move(current_states, symbol)
            dfa_transitions[(current_states, symbol)] = next_states
            if next_states not in visited:
                queue.append(next_states)

    return dfa_states, nfa.alphabet, dfa_transitions, dfa_start_state, dfa_accept_states

nfa_to_dfa 函数：将 NFA 转换为 DFA。
dfa_states：DFA 的状态集合。
dfa_transitions：DFA 的转移函数。
dfa_start_state：DFA 的起始状态，通过计算 NFA 起始状态的 epsilon-闭包得到。
dfa_accept_states：DFA 的接受状态集合。
queue：用于广度优先搜索的队列。
visited：记录已访问的状态集合。
在广度优先搜索过程中，计算每个状态集合对每个输入符号的转移，并更新 DFA 的状态和转移函数。

绘制 DFA 图像

def draw_dfa(dfa):
    dfa_states, alphabet, transitions, start_state, accept_states = dfa
    dot = graphviz.Digraph()
    dot.attr(rankdir='LR')  # 设置图的方向为从左到右

    # 添加状态节点
    for state in dfa_states:
        state_label = ','.join(sorted(state))  # 将状态集合转换为逗号分隔的字符串
        if state in accept_states:
            dot.node(state_label, shape='doublecircle')  # 接受状态用双圆圈表示
        else:
            dot.node(state_label, shape='circle')

    # 添加起始状态
    start_state_label = ','.join(sorted(start_state))
    dot.node("start", shape='point')  # 设置起始状态节点形状为点
    dot.edge("start", start_state_label)  # 添加从起始状态到第一个状态的边

    # 添加状态转移边
    for (current_state, symbol), next_state in transitions.items():
        current_state_label = ','.join(sorted(current_state))
        next_state_label = ','.join(sorted(next_state))
        dot.edge(current_state_label, next_state_label, label=symbol)  # 添加状态转移边

    dot.render('dfa', format='png', cleanup=True)  # 生成DFA的图像并保存为png格式

draw_dfa 函数：使用 Graphviz 生成 DFA 的图像。
dot：Graphviz 的 Digraph 对象。
设置图的方向为从左到右。
为每个状态添加节点，接受状态用双圆圈表示，其他状态用单圆圈表示。
添加起始状态的指示节点和边。
为每个状态转移添加带标签的边。
调用 render 方法生成并保存图像。