python实现DFA模拟程序(附java实现代码)

以下是Python实现DFA模拟程序的代码：

class DFA:
    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

    def run(self, input_string):
        current_state = self.start_state
        for symbol in input_string:
            if symbol not in self.alphabet:
                return False
            current_state = self.transitions[current_state][symbol]
        return current_state in self.accept_states


states = {0, 1, 2}
alphabet = {'0', '1'}
transitions = {
    0: {'0': 1, '1': 2},
    1: {'0': 0, '1': 1},
    2: {'0': 2, '1': 0}
}
start_state = 0
accept_states = {1}

dfa = DFA(states, alphabet, transitions, start_state, accept_states)

print(dfa.run('10101'))  # True
print(dfa.run('101011'))  # False

以下是Java实现DFA模拟程序的代码：

import java.util.*;

public class DFA {
    private Set<Integer> states;
    private Set<Character> alphabet;
    private Map<Integer, Map<Character, Integer>> transitions;
    private int startState;
    private Set<Integer> acceptStates;

    public DFA(Set<Integer> states, Set<Character> alphabet, Map<Integer, Map<Character, Integer>> transitions,
               int startState, Set<Integer> acceptStates) {
        this.states = states;
        this.alphabet = alphabet;
        this.transitions = transitions;
        this.startState = startState;
        this.acceptStates = acceptStates;
    }

    public boolean run(String inputString) {
        int currentState = startState;
        for (char symbol : inputString.toCharArray()) {
            if (!alphabet.contains(symbol)) {
                return false;
            }
            currentState = transitions.get(currentState).get(symbol);
        }
        return acceptStates.contains(currentState);
    }

    public static void main(String[] args) {
        Set<Integer> states = new HashSet<>(Arrays.asList(0, 1, 2));
        Set<Character> alphabet = new HashSet<>(Arrays.asList('0', '1'));
        Map<Integer, Map<Character, Integer>> transitions = new HashMap<>();
        transitions.put(0, new HashMap<>(Map.of('0', 1, '1', 2)));
        transitions.put(1, new HashMap<>(Map.of('0', 0, '1', 1)));
        transitions.put(2, new HashMap<>(Map.of('0', 2, '1', 0)));
        int startState = 0;
        Set<Integer> acceptStates = new HashSet<>(Collections.singletonList(1));

        DFA dfa = new DFA(states, alphabet, transitions, startState, acceptStates);

        System.out.println(dfa.run("10101")); // true
        System.out.println(dfa.run("101011")); // false
    }
}

注意：Python和Java版本的实现有所不同，但实现的功能是一样的。