dfa最小化，修正了上个版本的一些错误。

上个版本测试的时候，只用了两个非常简单的测试用例，所以好多情况有问题却没有测试出来

bug1：在生成diff_matrix的时候，循环变量少循环了一次，导致最后一个节点在如果无法与其他点合并的情况下，程序不会给他生成一个群标号。

修改：把循环变量那里加上等于号

bug2：在遍历群的时候，程序是以碰到空指针为结束的，但是在malloc内存的时候，系统并不为这个内存初始化为0，而是0xcd，所以以是不是空指针来判断边界是不可行的，会造成错误，导致读取了而外的信息。

修改：在遍历群的时候，直接以群的数目来做条件测试

bug3：在nfa转dfa的时候，如果某一个dfa节点在某一个字母上的转换导致了目标位图temp_nfa_set的第一个字节为空的情况下，在插入hash的过程中，直接调用strcpy程序会导致只复制第一个字节即结束字符，而忽略后面的那几个字节。从而导致在之后的查表中找不到这个位图。

修改：在hash复制名字的时候，用一个循环，直接一个字节一个字节的复制过去，这样就不会出现前面所说的情况了。

bug4：在re转nfa的时候，对于or的处理，如果or之前有操作符，在弹出该操作符的时候，会忘记为他生成token_node，导致后面的步骤都出现错误。这个问题出现的原因，是当时忘记写了。。。。。

修改：把忘记写的代码加上去。

bug5：在判断两个节点是否在dfa最小化的时候合并调用了is_diff,但是这里可能会出现无限递归的情况，例如节点1在a上到节点2，而节点2在a上到节点1。如果这时利用is_diff(1,2),会导致无限递归。

修改：每次调用is_diff(a,b)的时候，调用之前都在矩阵里面把这两个点所在的位置修改为2，2的意思是正在考虑。如果后面的调用查看到了标记为2的矩阵节点，则这次判断放弃，直接进入下次判断。如果is_diff返回了1，则把这个2修改为1，如果为0，则修改为0。

bug6：在re生成nfa的时候，自做聪明的采取了非标准的转换策略，后来证明有非常大的错误。例如(a|b)*|abc,如果按照我的那个生成策略生成的nfa图，会接受aabc这种情况。。。

修改 ：把re转nfa全都按照课本来做了。

目前我自己发现的就有这么多bug，欢迎大家测试

#include "nfa_to_dfa.h"
int* dfa_diff_matrix;

int mini_dfa_number;//这个是最小化的 dfa表的索引
typedef struct _min_dfa_node
{
    pdfa_edge begin;
    int is_end;//记录是否是接受节点
}min_dfa_node,*pmin_dfa_node;
min_dfa_node mini_dfa_table[100];//设定为100，其实也可以malloc一下，因为我们已经知道了有多少个节点了
//为了偷懒，算了
is_diff(int input_a,int input_b)//判断两个点是不是等价的程序,注意我们传参数的时候默认a比b大
{
    int destination_a,destination_b;//临时的转换目标地址,注意目标地址与矩阵索引是相差1的，注意啊
    pdfa_edge temp_edge;//遍历邻接表 
    char label_traverse;//用来遍历符号表

    int for_i;
    for(for_i=0;for_i<alpha_size;for_i++)
    {
        label_traverse=mini_alpha_set[for_i];
        temp_edge=current_dfa_table[input_a+1].begin;
        while((temp_edge!=NULL)&&(temp_edge->label!=label_traverse))
        {
            temp_edge=temp_edge->next;
        }
        if(temp_edge==NULL)
        {
            destination_a=0;
        }
        else
        {
            destination_a=temp_edge->dest_dfa_index;
        }//获得a的转换目标
        temp_edge=current_dfa_table[input_b+1].begin;
        while((temp_edge!=NULL)&&(temp_edge->label!=label_traverse))
        {
            temp_edge=temp_edge->next;
        }
        if(temp_edge==NULL)
        {
            destination_b=0;
        }
        else
        {
            destination_b=temp_edge->dest_dfa_index;
        }//获得b的转换目标
        if(destination_a==destination_b)
        {
            //目标相同，则无法判断，轮到下一次
        }
        else
        {
            if(destination_a*destination_b==0)
            {
                //如果刚好一个为0，说明可以判断
                return 1;
            }
            else
            {
                //因为目标地址的索引与矩阵地址的索引是相差1的，所以我们要这样做
                destination_a--;
                destination_b--;
                if( destination_a>destination_b)//按大小来分
                {
                    if(dfa_diff_matrix[dfa_node_number*(destination_a)+(destination_b)]!=2)
                        //这里是为了防止重复依赖导致的无限递归调用
                    {
                        if(dfa_diff_matrix[dfa_node_number*(destination_a)+(destination_b)]!=1)//如果当前无法判别
                        {
                            dfa_diff_matrix[dfa_node_number*(destination_a)+(destination_b)]=2;
                            if(is_diff(destination_a,destination_b))//如果可以判别 
                            {
                                dfa_diff_matrix[dfa_node_number*(destination_a)+(destination_b)]=1;
                                return 1;
                            }
                            else
                            {
                                dfa_diff_matrix[dfa_node_number*(destination_a)+(destination_b)]=0;
                            }
                        }
                        else
                        {
                            return 1;
                        }
                    }
                }
                else//如果b比a大
                {
                    if(dfa_diff_matrix[dfa_node_number*(destination_b)+(destination_a)]!=2)
                    {
                        if(dfa_diff_matrix[dfa_node_number*(destination_b)+(destination_a)]!=1)//如果当前无法判别
                        {
                            dfa_diff_matrix[dfa_node_number*(destination_b)+(destination_a)]=2;
                            if(is_diff(destination_b,destination_a))//如果可以判别 
                            {
                                dfa_diff_matrix[dfa_node_number*(destination_b)+(destination_a)]=1;
                                return 1;
                            }
                            else
                            {
                                dfa_diff_matrix[dfa_node_number*(destination_b)+(destination_a)]=0;
                            }
                        }
                        else
                        {
                            return 1;
                        }
                    }
                }
            }
        }
    }
    return 0;//如果所有的输入都轮完了，说明当前无法比较。。。
}
void diff_matrix(void)
{
    int already_diff_number;//这个是用来判断有多少个点已经经过了等价性测试
    int for_i,for_j;
    dfa_diff_matrix=malloc(sizeof(int)*dfa_node_number*dfa_node_number);//分配这个节点
    for(for_i=0;for_i<dfa_node_number;for_i++)
    {
        for(for_j=0;for_j<dfa_node_number;for_j++)
        {
            dfa_diff_matrix[(for_i)*dfa_node_number+for_j]=0;
        }
    }
    for(for_i=1;for_i<dfa_node_number;for_i++)
    {
        for(for_j=0;for_j<for_i;for_j++)//这里首先根据是否是接受节点来初始化矩阵
        {
            if(current_dfa_table[for_i+1].is_end!=current_dfa_table[for_j+1].is_end)
            {
                dfa_diff_matrix[(for_i)*dfa_node_number+for_j]=1;
            }
        }
    }
    do{
        already_diff_number=0;
        for(for_i=1;for_i<dfa_node_number;for_i++)
        {
            for(for_j=0;for_j<for_i;for_j++)
            {
                if(dfa_diff_matrix[(for_i)*dfa_node_number+for_j]!=1)
                {
                    dfa_diff_matrix[(for_i)*dfa_node_number+for_j]=2;
                    //做这个标记是为了防止递归调用，表明当前正在考虑的节点有哪些，不要再去试图考虑这些节点对
                    if(is_diff(for_i,for_j)==1)
                    {
                        dfa_diff_matrix[(for_i)*dfa_node_number+for_j]=1;
                        already_diff_number++;
                    }
                    else
                    {
                        dfa_diff_matrix[(for_i)*dfa_node_number+for_j]=0;
                    }
                }
            }
        }
    }while(already_diff_number!=0);//如果本趟处理没有找到新的可分节点，就结束 
    
    for(for_i=0;for_i<dfa_node_number;for_i++)
    {
        for(for_j=0;for_j<dfa_node_number;for_j++)
        {
            printf("%d ",dfa_diff_matrix[(for_i)*dfa_node_number+for_j]);
        }
        printf("\n");
    }
}
void minimize_dfa_matrix(void)//在已经构建好了dfa_diff_matrix后，开始群聚，并建图
{
    //现在开始群聚 
 int* already_in_group;//用来记录哪些点已经在群里面了
 int* temp_group;
 int* before_min_access;//这里来标注哪些节点已经通过了最简化dfa的转换 
 int group_number=0;//注意群号由0开始 
 int* index_of_group;
 pdfa_edge temp_edge;//这个是用来重新建立最小化dfa的临时边
 pdfa_edge temp_add_edge;//这个是用来往最小dfa里面增加边的临时边
 int dest_group_number;//这个是在增加边的时候的目标编号
 int **group_set;
 int for_i,for_j;
 group_set=malloc(sizeof(int)*dfa_node_number);
 already_in_group=malloc(sizeof(int)*dfa_node_number);
 for(for_i=0;for_i<dfa_node_number;for_i++)
 {
     already_in_group[for_i]=0;
     *(group_set+for_i)=NULL;
 }
 for(for_i=0;for_i<dfa_node_number;for_i++)//聚集 
 {
     if(already_in_group[for_i]==0)
     {
         already_in_group[for_i]=1;
         temp_group=malloc(sizeof(int)*dfa_node_number);
         *(group_set+group_number++)=temp_group;
         for(for_j=0;for_j<dfa_node_number;for_j++)
         {
             temp_group[for_j]=0;
         }//注意这里也需要考虑加减1的问题
         temp_group[for_i]=1;
         for(for_j=for_i+1;for_j<dfa_node_number;for_j++)
         {
             if(!dfa_diff_matrix[(for_j)*dfa_node_number+for_i])
             {
                 temp_group[for_j]=1;
                 already_in_group[for_j]=1;
             }
         }
     }
 }//现在已经完全都聚集为一团了
 mini_dfa_number=group_number;
 //现在再将节点和群的关系反转
 index_of_group=malloc(sizeof(int)*dfa_node_number);
 //这里又需要注意加减1的关系，由于这里dfa节点是从1标号的，而我们在index_of_group是从0标号的，要注意
 for(for_i=0;for_i<dfa_node_number;for_i++)
 {
     index_of_group[for_i]=0;
 }
 for_i=0;
 while(for_i<group_number)//前面开了一个索引数组，现在来赋值，这样就可以直接得到某个节点所在的群号
 {
     for(for_j=0;for_j<dfa_node_number;for_j++)
     {
         if(*(*(group_set+for_i)+for_j)==1)
         {
             index_of_group[for_j]=for_i;
         }
     }
     for_i++;
 }//现在关系已经翻转了
 //下一步就是利用这个点与群的关系来新建立一个dfa图
 //这里的群号就是节点的编号，由于每个群里面的节点都是等价的，所以只需要找一个节点就行了
 for(for_i=1;for_i<=group_number;for_i++)//这里的for_i是用来表示最小dfa图的标号，所以从1开始
 {
     //对每一个群进行遍历
     mini_dfa_table[for_i].begin=NULL;
     mini_dfa_table[for_i].is_end=0;
     for_j=0;
     while(*(*(group_set+for_i-1)+for_j)!=1)//由于group是从0开始标号的，所以要减去1
     {
         for_j++;
     }//找到这个群里面一个节点,注意加减一问题，少犯错误啊，1号节点存储在0号位置上
     if(current_dfa_table[for_j+1].is_end)//标记为结束节点
     {
         mini_dfa_table[for_i].is_end=1;
     }
     temp_edge=current_dfa_table[for_j+1].begin;
     while(temp_edge!=NULL)//重新建设邻接表
     {
         temp_add_edge=malloc(sizeof(struct _dfa_edge));
         temp_add_edge->label=temp_edge->label;
         temp_add_edge->next=mini_dfa_table[for_i].begin;
         dest_group_number=index_of_group[temp_edge->dest_dfa_index-1]+1;//特别要注意这里的加一和减一
         //由于temp_edge->dest_dfa_node是从1开始标号的，而index_of_group是从0开始标号的，所以我们要减一
         //同样，又由于最后的最简化dfa的图是从1开始标号的，所以我们要加1;
         temp_add_edge->dest_dfa_index=dest_group_number;
         mini_dfa_table[for_i].begin=temp_add_edge;
         temp_edge=temp_edge->next;
     }
     //本群的邻接表构建完成
 }//所有群的邻接表构建完成
}
void show_mini_dfa(void)//输出图
{
    int for_i;
    pdfa_edge temp_dfa_edge;
    number_of_end_dfa=0;
    for(for_i=1;for_i<=mini_dfa_number;for_i++)
    {
        if(mini_dfa_table[for_i].is_end==1)
        {
            printf("this node is an destination node ,index is %d\n",for_i);
        }
        temp_dfa_edge=mini_dfa_table[for_i].begin;
        while(temp_dfa_edge!=NULL)
        {
            printf("there is an dfa edge from %d to %d with label %c\n",for_i,temp_dfa_edge->dest_dfa_index,temp_dfa_edge->label);
            temp_dfa_edge=temp_dfa_edge->next;
        }
    }
    printf("the minimized dfa is completed\n");
}