设字母表为{a,b}，正规式为(ab|a)*b+,试为其画出NFA，并确定化为DFA，最后化简为最小DFA。

首先，我们可以使用 Thompson 构造法为正则表达式构造出一个 NFA。

第一步，构造正则表达式的子表达式 `ab` 和 `a` 的 NFA。

       ┌───a───┐
  ───►│   q1  │───┐
       └───┬───┘   │ b 
           │       ▼     
           └──────►q2

      ┌───a───┐
      │   q3  │
  ───►│       │───┐
      │   b   │   │ ε
      │       │◄──┘
      └───┬───┘
          │ ε
          ▼
         q4

然后，我们使用正则表达式中的或运算 `|` 将两个子表达式的 NFA 合并起来。

       ┌───a───┐           ┌───a───┐
  ───►│   q1  │───┐   ┌───►│   q3  │───┐
       └───┬───┘   │   │    └───┬───┘   │ b 
           │       ▼   │        │       ▼     
           └──────►q2  │        └──────►q4
                   │ ε │                │ ε
                   ▼   │                ▼
                  q5   └────────────────q6

接下来，使用闭包运算 `*` 将 `(ab|a)` 的 NFA 转换为一个可以接受零个或多个 `(ab|a)` 的 NFA。

      ┌───a───┐           ┌───a───┐
      │   q1  │───┐   ┌───►│   q3  │───┐
      └───┬───┘   │   │    └───┬───┘   │ b 
          │       ▼   │        │       ▼     
          └──────►q2  │        └──────►q4
                  │ ε │                │ ε
                  ▼   │                ▼
                 q5   └────────────────q6
                  │ ε │                │ ε
                  ▼   │                ▼
                  q7  └────────────────q8

最后，使用正则表达式中的 `+` 运算将 `b` 的 NFA 转换为一个可以接受一个或多个 `b` 的 NFA。

      ┌───a───┐           ┌───a───┐
      │   q1  │───┐   ┌───►│   q3  │───┐
      └───┬───┘   │   │    └───┬───┘   │ b 
          │       ▼   │        │       ▼     
          └──────►q2  │        └──────►q4
                  │ ε │                │ ε
                  ▼   │                ▼
                 q5   └────────────────q6
                  │ ε │                │ ε
                  ▼   │                ▼
                  q7  ─────b─────►q9───┘
                  │ ε │                │ ε
                  ▼   │                ▼
                 q10  ────────────────►q11

现在我们有了 NFA，接下来我们需要将其转换为 DFA。

首先，我们需要确定 NFA 的起始状态和终止状态。在上面的图中，起始状态为 `q1`，而终止状态为 `{q9, q11}`。

接下来，我们使用子集构造法将 NFA 转换为 DFA。

DFA 状态 | 转移条件 | 下一状态
-------------------------------
    A    |    a    |    B
    A    |    b    |    C
    B    |    a    |    B
    B    |    b    |    D
    C    |    a    |    B
    C    |    b    |    E
    D    |    a    |    B
    D    |    b    |    D
    E    |    a    |    B
    E    |    b    |    F
    F    |    a    |    B
    F    |    b    |    G
    G    |    a    |    B
    G    |    b    |    H
    H    |    a    |    B
    H    |    b    |    I
    I    |    a    |    B
    I    |    b    |    J
    J    |    a    |    B
    J    |    b    |    K
    K    |    a    |    B
    K    |    b    |    L
    L    |    a    |    B
    L    |    b    |    M
    M    |    a    |    B
    M    |    b    |    C*

我们可以从起始状态 `A` 开始，使用输入的字符 `a` 或 `b`，并在转移表中查找下一个状态。如果存在下一个状态，则将其设置为当前状态，并继续重复此过程，直到读取完整个输入字符串。如果最终状态是终止状态 `{q9, q11}`，则该字符串被接受。

最后，我们需要将 DFA 化简为最小 DFA。这可以通过状态合并来完成。我们可以使用状态等价性算法来找到可以合并的状态，并将它们合并为单个状态。在这种情况下，我们可以将状态 `{B,D,F,G,H,I,J,K,L,M}` 合并为单个状态 `X`，因为它们都具有相同的转移条件和下一个状态。

简化后的最小 DFA 如下所示：

DFA 状态 | 转移条件 | 下一状态
-------------------------------
    A    |    a    |    B
    A    |    b    |    C
    B    |    a    |    B
    B    |    b    |    X
    C    |    a    |    B
    C    |    b    |    E
    X    |    a    |    B
    X    |    b    |    X
    E    |    a    |    B
    E    |    b    |    F
    F    |    a    |    B
    F    |    b    |    X