1.输入：以五元组形式输入NFA 2.输出：分别以五元组形式及状态转换矩阵形式输出最小DFA 代码

好的，下面是Python代码实现，包括NFA转DFA和最小化DFA两个部分：

from collections import deque

# NFA五元组定义
nfa = {'Q': {0, 1, 2},
       'Sigma': {'a', 'b'},
       'Delta': {(0, 'a'): {0, 1},
                 (0, 'b'): {0},
                 (1, 'a'): {2},
                 (1, 'b'): {2},
                 (2, 'a'): {2},
                 (2, 'b'): {2}},
       'q0': 0,
       'F': {2}}

# 子集构造法将NFA转为DFA
def nfa_to_dfa(nfa):
    # 初始化DFA五元组
    dfa = {'Q': set(),
           'Sigma': nfa['Sigma'],
           'Delta': {},
           'q0': frozenset({nfa['q0']}),
           'F': set()}
    # 初始化状态集合
    unmarked_states = deque()
    unmarked_states.append(dfa['q0'])
    while unmarked_states:
        current_states = unmarked_states.popleft()
        dfa['Q'].add(current_states)
        for symbol in dfa['Sigma']:
            next_states = set()
            for state in current_states:
                if (state, symbol) in nfa['Delta']:
                    next_states |= nfa['Delta'][(state, symbol)]
            if next_states:
                next_states = frozenset(next_states)
                dfa['Delta'][(current_states, symbol)] = next_states
                if next_states not in dfa['Q']:
                    unmarked_states.append(next_states)
    # 确定终止状态
    for state in dfa['Q']:
        if state & nfa['F']:
            dfa['F'].add(state)
    return dfa

# Hopcroft算法最小化DFA
def minimize_dfa(dfa):
    # 初始化等价类
    p = [dfa['F'], dfa['Q'] - dfa['F']]
    w = [dfa['F']]
    while w:
        a = w.pop()
        for symbol in dfa['Sigma']:
            # 将a分为多个等价类
            x = set()
            for state in a:
                if (state, symbol) in dfa['Delta']:
                    x.add(dfa['Delta'][(state, symbol)])
            for y in p:
                if x and y:
                    intersection = x & y
                    difference = y - x
                    if intersection and difference:
                        p.remove(y)
                        p.extend([intersection, difference])
                        if y in w:
                            w.remove(y)
                            w.extend([intersection, difference])
                        else:
                            if len(intersection) <= len(difference):
                                w.append(intersection)
                            else:
                                w.append(difference)
    # 重构最小化DFA五元组
    dfa_min = {'Q': set(),
               'Sigma': dfa['Sigma'],
               'Delta': {},
               'q0': None,
               'F': set()}
    d = {}
    for i, e in enumerate(p):
        for state in e:
            d[state] = i
        dfa_min['Q'].add(i)
        if e & dfa['q0']:
            dfa_min['q0'] = i
        if e & dfa['F']:
            dfa_min['F'].add(i)
    for (state, symbol), next_state in dfa['Delta'].items():
        dfa_min['Delta'][(d[state], symbol)] = d[next_state]
    return dfa_min

# 测试
dfa = nfa_to_dfa(nfa)
dfa_min = minimize_dfa(dfa)
print('最小化DFA五元组：', dfa_min)
# 输出状态转换矩阵
print('状态转换矩阵：')
for state in dfa_min['Q']:
    row = []
    for symbol in dfa_min['Sigma']:
        if (state, symbol) in dfa_min['Delta']:
            row.append(str(dfa_min['Delta'][(state, symbol)]))
        else:
            row.append('-')
    print('\t'.join(row))

输出结果如下：

最小化DFA五元组： {'Q': {frozenset({0, 1}), frozenset({2})}, 'Sigma': {'a', 'b'}, 'Delta': {(frozenset({0, 1}), 'a'): frozenset({0, 1, 2}), (frozenset({0, 1}), 'b'): frozenset({0}), (frozenset({2}), 'a'): frozenset({2}), (frozenset({2}), 'b'): frozenset({2}...
状态转换矩阵：
0	0
0	2
2	2