DFA最小化 -- Hopcroft算法 Python实现

wiki 伪代码看上去一直以为怪。发现葡萄牙语和俄罗斯语那里的 if 推断都还缺少一个条件。

国内的资料比較少。这几份学习资料不错。比我稀里糊涂的思路要好，分享下：

http://www.liafa.univ-paris-diderot.fr/~carton/Enseignement/Complexite/

ENS/Redaction/2008-2009/yingjie.xu.pdf

http://www8.cs.umu.se/kurser/TDBC92/VT06/final/1.pdf

http://arxiv.org/pdf/1010.5318.pdf

对于一个确定型自己主动机 D = (Q, Σ, δ, q0, F)。Q 的一系列恒等关系 ρi (i ≥ 0) 被定义为：

ρ0 = {(p, q)|p, q ∈ F} ∪ {(p, q)|p, q ∈ Q − F},

ρi+1 = {(p, q) ∈ ρi|(∀a ∈ Σ)(δ(p, a), δ(q, a)) ∈ ρi}.

ρi有例如以下关系：

ρ0 ⊇ ρ1 ⊇ · · · .

若 ρi = ρi+1 则对于 ρi = ρj (j > i).

存在 0 ≤ k ≤ |Q| 满足 ρk = ρk+1.

对于 ρi ≠ ρi+1，存在下面性质Equation 1：

ρi ≠ ρi+1    ⇔ (∃p, q ∈ Q, a ∈ Σ) (p, q) ∈ ρi and (δ(p, a), δ(q, a)) ∉ ρi

⇔ (∃U ∈ Q/ρi , a ∈ Σ) p, q ∈ U and (δ(p, a), δ(q, a)) ∉ ρi

⇔ (∃U, V ∈ Q/ρi , a ∈ Σ) p, q ∈ U and δ(p, a) ∈ V and δ(q, a) ∉ V

⇔ (∃U, V ∈ Q/ρi , a ∈ Σ) δ(U, a) ∩ V ≠ ∅ and δ(U, a) ∉ V

算法抽象：

1: Q/θ ← {F, Q − F}

2: while (∃U, V ∈ Q/θ, a ∈ Σ) s.t. Equation 1 holds do

3: Q/θ ← (Q/θ − {U}) ∪ {U ∩ δ^-1(V, a), U − U ∩ δ^-1(V, a)}

4: end while

算法细化：

1:W ← {F, Q − F}    # 有些版本号上仅仅是 W ← {F }

2: P ← {F, Q − F}

3: while W is not empty do

4:     select and remove S from W

5:     for all a ∈ Σ do

6:         la ← δ^-1(S, a)

7:         for all R in P such that R ∩ la ≠ ∅ and R ∉ la do

8:             partition R into R1 and R2: R1 ← R ∩ la and R2 ← R − R1

9:             replace R in P with R1 and R2

10:           if R ∈ W then

11:               replace R in W with R1 and R2

12:           else

13:                 if |R1| ≤ |R2| then

14:                     add R1 to W

15:                 else

16:                     add R2 to W

17:                 end if

18:             end if

19:         end for

20:     end for

21: end while

复杂度：

O(n log n)

另一个优化的代码：

1: P = {F, Q − F}

2:     for all a ∈ A do

3:         Add((min(F, Q − F), a), S)

4:     while S ≠ ∅ do

5:         get (C, a) from S (we extract (C, a) according to the

strategy associated with S: FIFO/LIFO/...)

6:         for each B ∈ P split by (C, a) do

7:             B′, B′′ are the sets resulting from splitting of B w.r.t. (C, a)

8:             Replace B in P with both B′ and B′′

9:             for all b ∈ A do

10:                if (B, b) ∈ S then

11:                    Replace (B, b) by (B′, b) and (B′′, b) in S

12:                else

13:                    Add((min(B′,B′′), b), S)

找出无用状态：

state_graph1 = {
    'total_states': [ 'A', 'B', 'C', 'D', 'E' ],
    'initial_states': [ 'A' ],
    'termination_states': [ 'D' ],
    'state_transition_map': {
        'A': { 'a': 'B', 'b': 'C' },
        'B': { 'a': 'B', 'b': 'D' },
        'C': { 'a': 'B' },
        'E': { 'a': 'E', 'b': 'E', },
        'D': { 'a': 'B' },
    },
    'cins': [ 'a', 'b' ],
}

def get_unreachable_states( G ):
    reachable_states      = set( G['initial_states'] )
    new_states            = set( G['initial_states'] )
    total_states          = set( G['total_states'] )
    cins                  = G['cins']
    state_transition_map  = G['state_transition_map']

    while True:
        temp_set = set()
        for state in new_states:
            for char in cins:
                try:
                    next_state = state_transition_map[state][char]
                    temp_set.update( next_state )
                except KeyError:
                    pass

        new_states = temp_set - reachable_states
        reachable_states.update( temp_set )
        if new_states == set():
            break

    unreachable_states = total_states - reachable_states
    return unreachable_states

print get_unreachable_states( state_graph1 )

Hopcroft：

import random
from copy import deepcopy

state_graph1 = {
    'total_states': [ '1', '2', '3', '4', '5', '6', '7' ],
    'initial_states': [ '1' ],
    'termination_states': [ '6', '7' ],
    'state_transition_map': {
        '1': { 'a': '3', 'b': '2' },
        '2': { 'a': '4', 'b': '2' },
        '3': { 'c': '3', 'b': '6', 'd': '5' },
        '4': { 'b': '7', 'd': '5', 'c': '3' },
        '5': { 'a': '4' },
        '6': { 'b': '6' },
        '7': { 'b': '6' },
    },
    'cins': [ 'a', 'b', 'c', 'd' ],
}

state_graph2 = {
    'total_states': [ 'A', 'B', 'C', 'D', 'E', 'F', 'S' ],
    'initial_states': [ 'A' ],
    'termination_states': [ 'C', 'D', 'E', 'F' ],
    'state_transition_map': {
        'S': { 'a': 'A', 'b': 'B' },
        'A': { 'a': 'C', 'b': 'B' },
        'B': { 'a': 'A', 'b': 'D' },
        'C': { 'a': 'C', 'b': 'E' },
        'D': { 'a': 'F', 'b': 'D' },
        'E': { 'a': 'F', 'b': 'D' },
        'F': { 'a': 'C', 'b': 'E' },
    },
    'cins': [ 'a', 'b' ],
}

state_graph3 = {
    'total_states': [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' ],
    'initial_states': [ 'A' ],
    'termination_states': [ 'C' ],
    'state_transition_map': {
        'A': { '0': 'B', '1': 'F' },
        'B': { '0': 'G', '1': 'C' },
        'C': { '0': 'A', '1': 'C' },
        'D': { '0': 'C', '1': 'G' },
        'E': { '0': 'H', '1': 'F' },
        'F': { '0': 'C', '1': 'G' },
        'G': { '0': 'G', '1': 'E' },
        'H': { '0': 'G', '1': 'C' }
    },
    'cins': [ '0', '1' ],
}

def hopcroft_algorithm( G ):
    cins                   = set( G['cins'] )
    termination_states     = set( G['termination_states'] )
    total_states           = set( G['total_states'] )
    state_transition_map   = G['state_transition_map']
    not_termination_states = total_states - termination_states

    def get_source_set( target_set, char ):
        source_set = set()
        for state in total_states:
            try:
                if state_transition_map[state][char] in target_set:
                    source_set.update( state )
            except KeyError:
                pass
        return source_set

    P = [ termination_states, not_termination_states ]
    W = [ termination_states, not_termination_states ]

    while W:

        A = random.choice( W )
        W.remove( A )

        for char in cins:
            X = get_source_set( A, char )
            P_temp = []

            for Y in P:
                S  = X & Y
                S1 = Y - X

                if len( S ) and len( S1 ):
                    P_temp.append( S )
                    P_temp.append( S1 )

                    if Y in W:
                        W.remove( Y )
                        W.append( S )
                        W.append( S1 )
                    else:
                        if len( S ) <= len( S1 ):
                            W.append( S )
                        else:
                            W.append( S1 )
                else:
                    P_temp.append( Y )
            P = deepcopy( P_temp )
    return P

print hopcroft_algorithm( state_graph1 )
print hopcroft_algorithm( state_graph2 )
print hopcroft_algorithm( state_graph3 )

岛津义弘：

“真田幸村，这片 ‘ 战国 ’ 的土地上有太多的冷漠和争斗。

一个人想要在这种 ‘ 乱世 ’ 中心存温和。他前进的道路定然会非常痛苦，

可是最后能走到 ‘ 武 ’ 之巅峰的人，却往往又都是那样内心温和的人。

由于这份温和可以让人变得非常强壮。

希望你即便面对的是你的敌人，挥舞自己的 ‘ 双枪 ’ 时，也不要失去这份温和。”

版权声明：本文博客原创文章，博客，未经同意，不得转载。