internal static void MinimizeHopcroft(Automaton a)
{
a.Determinize();
IList <Transition> tr = a.Initial.Transitions;
if (tr.Count == 1)
{
Transition t = tr[0];
if (t.To == a.Initial && t.Min == char.MinValue && t.Max == char.MaxValue)
{
return;
}
}
a.Totalize();
// Make arrays for numbered states and effective alphabet.
HashSet <State> ss = a.GetStates();
var states = new State[ss.Count];
int number = 0;
foreach (State q in ss)
{
states[number] = q;
q.Number = number++;
}
char[] sigma = a.GetStartPoints();
// Initialize data structures.
var reverse = new List <List <LinkedList <State> > >();
foreach (State s in states)
{
var v = new List <LinkedList <State> >();
Initialize(ref v, sigma.Length);
reverse.Add(v);
}
var reverseNonempty = new bool[states.Length, sigma.Length];
var partition = new List <LinkedList <State> >();
Initialize(ref partition, states.Length);
var block = new int[states.Length];
var active = new StateList[states.Length, sigma.Length];
var active2 = new StateListNode[states.Length, sigma.Length];
var pending = new LinkedList <IntPair>();
var pending2 = new bool[sigma.Length, states.Length];
var split = new List <State>();
var split2 = new bool[states.Length];
var refine = new List <int>();
var refine2 = new bool[states.Length];
var splitblock = new List <List <State> >();
Initialize(ref splitblock, states.Length);
for (int q = 0; q < states.Length; q++)
{
splitblock[q] = new List <State>();
partition[q] = new LinkedList <State>();
for (int x = 0; x < sigma.Length; x++)
{
reverse[q][x] = new LinkedList <State>();
active[q, x] = new StateList();
}
}
// Find initial partition and reverse edges.
foreach (State qq in states)
{
int j = qq.Accept ? 0 : 1;
partition[j].AddLast(qq);
block[qq.Number] = j;
for (int x = 0; x < sigma.Length; x++)
{
char y = sigma[x];
State p = qq.Step(y);
reverse[p.Number][x].AddLast(qq);
reverseNonempty[p.Number, x] = true;
}
}
// Initialize active sets.
for (int j = 0; j <= 1; j++)
{
for (int x = 0; x < sigma.Length; x++)
{
foreach (State qq in partition[j])
{
if (reverseNonempty[qq.Number, x])
{
active2[qq.Number, x] = active[j, x].Add(qq);
}
}
}
}
// Initialize pending.
for (int x = 0; x < sigma.Length; x++)
{
int a0 = active[0, x].Size;
int a1 = active[1, x].Size;
int j = a0 <= a1 ? 0 : 1;
pending.AddLast(new IntPair(j, x));
pending2[x, j] = true;
}
// Process pending until fixed point.
int k = 2;
while (pending.Count > 0)
{
IntPair ip = pending.RemoveAndReturnFirst();
int p = ip.N1;
int x = ip.N2;
pending2[x, p] = false;
// Find states that need to be split off their blocks.
for (StateListNode m = active[p, x].First; m != null; m = m.Next)
{
foreach (State s in reverse[m.State.Number][x])
{
if (!split2[s.Number])
{
split2[s.Number] = true;
split.Add(s);
int j = block[s.Number];
splitblock[j].Add(s);
if (!refine2[j])
{
refine2[j] = true;
refine.Add(j);
}
}
}
}
// Refine blocks.
foreach (int j in refine)
{
if (splitblock[j].Count < partition[j].Count)
{
LinkedList <State> b1 = partition[j];
LinkedList <State> b2 = partition[k];
foreach (State s in splitblock[j])
{
b1.Remove(s);
b2.AddLast(s);
block[s.Number] = k;
for (int c = 0; c < sigma.Length; c++)
{
StateListNode sn = active2[s.Number, c];
if (sn != null && sn.StateList == active[j, c])
{
sn.Remove();
active2[s.Number, c] = active[k, c].Add(s);
}
}
}
// Update pending.
for (int c = 0; c < sigma.Length; c++)
{
int aj = active[j, c].Size;
int ak = active[k, c].Size;
if (!pending2[c, j] && 0 < aj && aj <= ak)
{
pending2[c, j] = true;
pending.AddLast(new IntPair(j, c));
}
else
{
pending2[c, k] = true;
pending.AddLast(new IntPair(k, c));
}
}
k++;
}
foreach (State s in splitblock[j])
{
split2[s.Number] = false;
}
refine2[j] = false;
splitblock[j].Clear();
}
split.Clear();
refine.Clear();
}
// Make a new state for each equivalence class, set initial state.
var newstates = new State[k];
for (int n = 0; n < newstates.Length; n++)
{
var s = new State();
newstates[n] = s;
foreach (State q in partition[n])
{
if (q == a.Initial)
{
a.Initial = s;
}
s.Accept = q.Accept;
s.Number = q.Number; // Select representative.
q.Number = n;
}
}
// Build transitions and set acceptance.
foreach (State s in newstates)
{
s.Accept = states[s.Number].Accept;
foreach (Transition t in states[s.Number].Transitions)
{
s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number]));
}
}
a.RemoveDeadTransitions();
}
/// <summary>
/// Determinizes the given automaton using the given set of initial states.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="initialset">The initial states.</param>
public static void Determinize(Automaton a, List<State> initialset)
{
char[] points = a.GetStartPoints();
var comparer = new ListEqualityComparer<State>();
// Subset construction.
var sets = new Dictionary<List<State>, List<State>>(comparer);
var worklist = new LinkedList<List<State>>();
var newstate = new Dictionary<List<State>, State>(comparer);
sets.Add(initialset, initialset);
worklist.AddLast(initialset);
a.Initial = new State();
newstate.Add(initialset, a.Initial);
while (worklist.Count > 0)
{
List<State> s = worklist.RemoveAndReturnFirst();
State r;
newstate.TryGetValue(s, out r);
foreach (State q in s)
{
if (q.Accept)
{
r.Accept = true;
break;
}
}
for (int n = 0; n < points.Length; n++)
{
var set = new HashSet<State>();
foreach (State c in s)
foreach (Transition t in c.Transitions)
if (t.Min <= points[n] && points[n] <= t.Max)
set.Add(t.To);
var p = set.ToList();
if (!sets.ContainsKey(p))
{
sets.Add(p, p);
worklist.AddLast(p);
newstate.Add(p, new State());
}
State q;
newstate.TryGetValue(p, out q);
char min = points[n];
char max;
if (n + 1 < points.Length)
{
max = (char)(points[n + 1] - 1);
}
else
{
max = char.MaxValue;
}
r.Transitions.Add(new Transition(min, max, q));
}
}
a.IsDeterministic = true;
a.RemoveDeadTransitions();
}
/// <summary>
/// Determinizes the given automaton using the given set of initial states.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="initialset">The initial states.</param>
public static void Determinize(Automaton a, List <State> initialset)
{
char[] points = a.GetStartPoints();
var comparer = new ListEqualityComparer <State>();
// Subset construction.
var sets = new Dictionary <List <State>, List <State> >(comparer);
var worklist = new LinkedList <List <State> >();
var newstate = new Dictionary <List <State>, State>(comparer);
sets.Add(initialset, initialset);
worklist.AddLast(initialset);
a.Initial = new State();
newstate.Add(initialset, a.Initial);
while (worklist.Count > 0)
{
List <State> s = worklist.RemoveAndReturnFirst();
State r;
newstate.TryGetValue(s, out r);
foreach (State q in s)
{
if (q.Accept)
{
r.Accept = true;
break;
}
}
for (int n = 0; n < points.Length; n++)
{
var set = new HashSet <State>();
foreach (State c in s)
{
foreach (Transition t in c.Transitions)
{
if (t.Min <= points[n] && points[n] <= t.Max)
{
set.Add(t.To);
}
}
}
var p = set.ToList();
if (!sets.ContainsKey(p))
{
sets.Add(p, p);
worklist.AddLast(p);
newstate.Add(p, new State());
}
State q;
newstate.TryGetValue(p, out q);
char min = points[n];
char max;
if (n + 1 < points.Length)
{
max = (char)(points[n + 1] - 1);
}
else
{
max = char.MaxValue;
}
r.Transitions.Add(new Transition(min, max, q));
}
}
a.IsDeterministic = true;
a.RemoveDeadTransitions();
}