用于构建接受以字符{0, 1} 结尾的以“01”结尾的语言的 DFA 的程序

给定一个二进制字符串str ，任务是构建一个 DFA，该 DFA 接受字符{0, 1} 上以“01”结尾的语言。

例子：

Input: str = “00011101”
Output: String Accepted
Explanation:
As the given string ends with “01”, therefore, it is accepted.

Input: str = “00001111”
Output: String Rejected
Explanation:
As the given string ends with “11”, therefore, it is rejected.

方法：为了解决上述问题，下面是需要的类状态和成员函数：

• 对 1：它处理第一种类型的输入，即 0，并将其与指向下一个状态的对象指针链接。
• Pair 2：它处理第二种类型的输入，即 1，并将它与指向下一个状态的对象指针链接起来。
• m_x：它定义了特定状态是初始状态还是最终状态。

类成员函数定义如下：

• initialize()：该函数将两对(用于两种输入)与状态定义字符(i 或 f)一起作为参数。
• transition()：它充当自动机的转换表，并通过特定输入从一个状态转到下一个状态。
• traverse()：该函数接受输入字符串并将其传递给自动机。
• check()：该函数检查输入结束后的结束状态是否为最终状态。如果它是最终的，则接受该字符串，否则拒绝。

对于这个问题，需要三个状态。因此，创建三类对象并使用所需的值将它们初始化为：

• 状态 1：在输入 0 上它进入状态 2，在输入 1 上它进入自身。
• 状态 2：在输入 0 上它转到自身，在输入 1 上它转到状态 3。
• 状态 3：在输入 0 上它进入状态 2，在输入 1 上进入状态 1。此外，这是我们的最终状态。

下面是上述方法的实现：

C++14

// C++ program of a DFA that accepts
// all string ending with "01"
  
#include 
#include 
using namespace std;
  
// Class for automata
class State {
private:
    // Data members to store the input
    pair Pair1;
    pair Pair2;
    char m_x;
  
public:
    // Pointer to the state of automata
    static State* m_ptr;
  
    // Constructor to initialize state
    State()
    {
        Pair1.first = 0;
        Pair1.second = nullptr;
        Pair2.first = 0;
        Pair2.second = nullptr;
        m_x = ' ';
    }
  
    // Initialise pair1 and pair2
    // with state x
    void initialize(
        pair pair1,
        pair pair2, char x)
    {
        Pair1 = pair1;
        Pair2 = pair2;
        m_x = x;
    }
  
    // Passes a string through automata
    static void transition(int input);
    static void traverse(string& str, int n);
  
    // Checks if the last state
    // is final or not
    static void check();
};
  
// Pointer to the current
// state of automata
State* State::m_ptr{ nullptr };
  
// Function to provide state
// transition of automata
void State::transition(int input)
{
    if ((*m_ptr).Pair1.first == input)
        m_ptr = (*m_ptr).Pair1.second;
    else
        m_ptr = (*m_ptr).Pair2.second;
}
  
// Checks if the last state
// is final or not
void State::check()
{
    if ((*m_ptr).m_x == 'f')
        cout << "String Accepted\n"
             << endl;
    else
        cout << "String Rejected\n"
             << endl;
}
  
// Passes a string through automata
void State::traverse(string& str, int n)
{
    for (int i = 0; i < n; i++) {
        int x{ (int)str[i] - (int)'0' };
        transition(x);
    }
}
  
// Function to check if the given
// is accepted in DFA or not
void isAccepted(string str)
{
    // States of the automata
    State one, two, three;
  
    // Transition table for required
    // automata
    one.initialize({ 0, &two },
                   { 1, &one }, 'i');
    two.initialize({ 0, &two },
                   { 1, &three }, 'i');
    three.initialize({ 0, &two },
                     { 1, &one }, 'f');
  
    int length{ static_cast(str.length()) };
    State::m_ptr = &one;
  
    // Function call
    State::traverse(str, length);
    State::check();
}
  
// Driver Code
int main()
{
    string str{ "00111101" };
  
    isAccepted(str);
  
    return 0;
}

输出：

String Accepted

时间复杂度： O(N)
辅助空间： O(1)