DFA 最小化算法：Sameless() 函数实现

该代码实现了一个 DFA 最小化的算法。具体步骤如下：

1. 首先将所有非终止状态放在一个集合中，将所有终止状态放在另一个集合中。

2. 对于每个集合，找到它可以转移到的所有其他集合，并将这些集合加入到一个新的集合中。

3. 重复第二步，直到没有新的集合可以被加入。

4. 经过以上步骤，得到的集合就是最小化后的 DFA 状态集合。

5. 将每个状态的转移关系更新为新的最小化状态集合中的状态。

具体实现中，代码首先对所有非终止状态进行处理，将它们放在一个集合中，并对集合中的状态进行排序。然后将终止状态集合添加到结果集合中。

接下来，代码通过循环遍历每个集合，找到它可以转移到的其他集合。如果没有新的集合可以被加入，就退出循环。否则，将新的集合添加到结果集合中，并将原集合中不属于新集合的状态放入另一个集合中。

最后，代码将每个状态的转移关系更新为新的最小化状态集合中的状态。

public void Sameless()
{
    List<List<int>> result = new List<List<int>>();
    List<int> e = new List<int>();
    for (int i = 0; i < dfa_list.Count; i++)
    {
        if (!end_list.Contains(dfa_list[i].start) && !e.Contains(dfa_list[i].start))
        {
            e.Add(dfa_list[i].start);
        }
    }
    e.Sort();
    if (e.Count != 0)
        result.Add(e);
    result.Add(end_list);
    int count = 0;
    while (count < result.Count)
    {
        List<int> E = new List<int>();
        E = result[count];
        if (count == result.Count - 1) // 终结状态
        {
            num_end = findtype(result, E[0]);
        }
        List<int> L = new List<int>();
        for (int i = 0; i < sign_list.Count; i++)
        {
            int x = findtype(result, findlast(E[0], sign_list[i]));
            for (int j = 0; j < E.Count; j++)
            {
                if (findlast(E[j], sign_list[i]) != -1 && findtype(result, findlast(E[j], sign_list[i])) != x && !L.Contains(E[j]))
                {
                    L.Add(E[j]);
                }
            }
        }
        if (L.Count == 0)
        {
            count++;
        }
        else
        {
            List<int> J = new List<int>();
            for (int x = 0; x < E.Count; x++)
            {
                if (!L.Contains(E[x]))
                {
                    J.Add(E[x]);
                }
            }
            result.RemoveAt(count);
            result.Insert(count, J);
            result.Insert(count + 1, L);
        }
    }

    for (int i = 0; i < result.Count; i++)
    {
        for (int j = 0; j < dfa_list.Count; j++)
        {
            if (dfa_list[j].start == result[i][0])
            {
                FA fa = new FA();
                fa.start = findtype(result, dfa_list[j].start);
                fa.to = dfa_list[j].to;
                fa.end = findtype(result, dfa_list[j].end);
                if (!mfa_list.Contains(fa))
                    mfa_list.Add(fa);
            }
        }
    }
}

public int findlast(int s, char a)
{
    for (int i = 0; i < dfa_list.Count; i++)
    {
        if (dfa_list[i].start == s && dfa_list[i].to == a)
        {
            return dfa_list[i].end;
        }
    }
    return -1;
}

public int findtype(List<List<int>> result, int type)
{
    for (int i = 0; i < result.Count; i++)
    {
        if (result[i].Contains(type))
            return i;
    }
    return -1;
}