自动机确定化

最新推荐文章于 2024-10-15 20:46:17 发布
最新推荐文章于 2024-10-15 20:46:17 发布
阅读量455 收藏 2
点赞数 1
分类专栏： 编译原理 文章标签： 有限状态自动机 NFA DFA 状态转换 字符集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53369146/article/details/121209029
版权 
#include<stdio.h>
#include<windows.h>

typedef struct{
    int state[100];  //状态集合
    int snum=0;       //状态个数
    int N=0;          //符号个数
    //int index;      //自身编号
    int index[100];        //符号      
    int to[100][100];    //状态转移到的集合

}ND;
ND NFA[100],DFA[100];
typedef struct{
    int beg[100];//开始状态
    int end[100];//结束状态
    int smnm;//字符个数
    int statenm;//状态个数
    int dfanm=0;
    int nnm;
    int ssm[100]={-1};
}declare;
declare DL;
int findnfa(int state,int n){
    for(int i=0;i<n;i++)
        if(NFA[i].state[0]==state)return i;
    return n; 
}
int length(int a[]){
    int i=0;
    while(a[i]!=-1)i++;
    return i;

}
void NTODREAD(){
    FILE *fp;
    char name[20];
    scanf("%s",&name);
    if((fp=fopen(name,"r"))==NULL)exit(0);
    while(!feof(fp)){
        fscanf(fp,"%d",&DL.statenm);
        for(int i=0;i<DL.statenm;i++)
            {NFA[i].index[1]=-1;
             NFA[i].to[0][0]=-1;
            }
        fscanf(fp,"%d",&DL.smnm);
        int flag,x,i=0;
        NFA[i].N=0;NFA[i].snum=0;
        fscanf(fp,"%d",&x);
        flag=x;
        while(x!=-1){
            int ii=findnfa(x,i);
            if(ii==i)i++;
            NFA[ii].state[0]=x;
            fscanf(fp,"%d",&x);
            NFA[ii].index[NFA[ii].N++]=x;
            int k=0;
            fscanf(fp,"%d",&x);
            while(x!=-1){
                NFA[ii].to[NFA[ii].index[NFA[ii].N-1]][k++]=x;
                fscanf(fp,"%d",&x);
            }
            NFA[ii].to[NFA[ii].index[NFA[ii].N-1]][k++]=-1;
            fscanf(fp,"%d",&x);
            
        }
        DL.nnm=i;
        fscanf(fp,"%d",&x);
        i=0;
        while(x!=-1){
            DL.beg[i++]=x;
            fscanf(fp,"%d",&x);
        }
        DL.beg[i]=-1;
        fscanf(fp,"%d",&x);
        i=0;
        while(x!=-1){
            DL.end[i++]=x;
            fscanf(fp,"%d",&x);
        }
        DL.end[i]=-1;
    }
    fclose(fp);
    if(DL.statenm!=DL.nnm){
        for(int i=0;i<DL.nnm;i++){
            for(int j=0;j<NFA[i].N;j++){
                for(int k=0;k<length(NFA[i].to[NFA[i].index[j]]);k++)
                    {
                        int l=findnfa(NFA[i].to[NFA[i].index[j]][k],DL.nnm);
                        if(l==DL.nnm){
                            DL.nnm++;
                            
                            NFA[l].state[0]=NFA[i].to[NFA[i].index[j]][k];
                            NFA[l].N=0;
                            NFA[l].index[0]=-1;
                            for(int m=0;m<DL.smnm;m++)
                                NFA[l].to[DL.ssm[m]][0]=-1;
                        }
                    }
            }

        }


    }
    for(int i=0;i<DL.statenm;i++)
        NFA[i].index[NFA[i].N]=-1;
    //NFA[10].index[0]=-1;    

}
void NTODWRITE(){
    printf("NFA:\n");
    for(int i=0;i<DL.statenm;i++){
        for(int j=0;j<NFA[i].N;j++)
            {printf("%d %d ",NFA[i].state[0],NFA[i].index[j]);
             int k=0;
             while(NFA[i].to[NFA[i].index[j]][k]!=-1){
                 printf("%d ",NFA[i].to[NFA[i].index[j]][k]);
                 k++;
             }   
             printf("\n");
            }
        printf("\n");
    }
}

int isin(int a[],int x){
    int le=length(a);
    for(int i=0;i<le;i++)
        if(a[i]==x)return 1;
    return 0;
}
int nfainfo(int a){
    for(int i=0;i<DL.statenm;i++)
        if(NFA[i].state[0]==a)return i;
    return -1;
}
void sort(int a[],int left,int right){
	int i,j,temp,t;
	if(left>right){
		return ;
	}
	temp = a[left];
	i  = left;
	j = right;
	while(i!=j){
		while(a[j]>=temp&&i<j)
			j--;
		while(a[i]<=temp&&i<j)
			i++;
		if(i<j){
			t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
	}
	a[left] = a[i];
	a[i] = temp;
	sort(a,left,i-1);
	sort(a,i+1,right);
}
int comp(int a[],int b[]){
    int a1[100],b1[100];
    int la=length(a),lb=length(b);
    if((la-lb)!=0)return 0;
    for(int i=0;i<la;i++){
        a1[i]=a[i];
        b1[i]=b[i];
    }
    sort(a1,0,la-1);
    sort(b1,0,la-1);
    for(int i=0;i<la;i++)
        if((a1[i]-b1[i])!=0)return 0;
    return 1;
}
int FINDDFA(int a[]){
    for(int i=0;i<DL.dfanm;i++)
        if(comp(a,DFA[i].state))return i;
    return -1;


}
void FINDSYM(){
    int t=0;
    for(int i=0;i<DL.statenm;i++){
        for(int j=0;j<NFA[i].N;j++)
            if(isin(DL.ssm,NFA[i].index[j])==0&&NFA[i].index[j]!=0)
                {DL.ssm[t++]=NFA[i].index[j];DL.ssm[t]=-1;}
    }


}
void FIND0(int a[]){
    int c[100],la=length(a),lc=la;
    //printf("la=%d\n",la);
    for(int i=0;i<=la;i++)
        c[i]=a[i];
    for(int i=0;i<la;i++){
        int t=nfainfo(a[i]);
        //printf("i=%d\n",i);
        //printf("t=%d\n",t);
        if(t!=-1){
            if(isin(NFA[t].index,0)){
                int j=0;
                while(NFA[t].to[0][j]!=-1)
                    {
                        if(isin(a,NFA[t].to[0][j])==0)a[la++]=NFA[t].to[0][j];
                        j++;
                        //printf("j=%d\n",j);
                    }

            }

        }

    }
    a[la]=-1;

}
void NTOD(){
    
    printf("DFA:\n");
    int temp[100];
    int i=0;
    while(DL.beg[i]!=-1){
        DFA[0].state[i]=DL.beg[i];
        i++;
    }
    
    //printf("i=%d\n",i);
    DFA[0].state[i]=-1;
    DL.dfanm++;
    FIND0(DFA[0].state);
    FINDSYM();
    //printf("length=%d\n",length(DFA[0].state));
    //int a[]={0,1,2,4,7,-1};
    //printf("finddfa=%d\n",FINDDFA(a));
    /*
        i=0;
        while(DFA[0].state[i]!=-1){
        printf("%d ",DFA[0].state[i]);
        i++;
    }*/
    /*FINDSYM();
    for(int i=0;i<length(DL.ssm);i++)
        printf("%d ",DL.ssm[i]);
        //输出字符集
        */
    for(int i=0;i<DL.dfanm;i++){
        //printf("i=%d\n",i);
        int len=length(DFA[i].state);
        int temp[100]={-1},tpi=0;
        DFA[i].index[length(DL.ssm)]=-1;
        for(int k=0;k<length(DL.ssm);k++){
            tpi=0;
            //printf("k=%d\n",k);
            DFA[i].index[k]=DL.ssm[k];
            
            for(int j=0;j<len;j++){
                int info=nfainfo(DFA[i].state[j]);
                if(isin(NFA[info].index,0)){
                    int ni=0;
                    while(NFA[info].to[0][ni]!=-1){
                        if(isin(temp,NFA[info].to[0][ni])==0)
                            {temp[tpi++]=NFA[info].to[0][ni];
                                temp[tpi]=-1;
                            }
                        ni++;
                        //printf("ni=%d\n",ni);
                    }
                }
                if(isin(NFA[info].index,DL.ssm[k])){
                    int ni=0;
                    while(NFA[info].to[DL.ssm[k]][ni]!=-1){
                        if(isin(temp,NFA[info].to[DL.ssm[k]][ni])==0)
                            {temp[tpi++]=NFA[info].to[DL.ssm[k]][ni]; temp[tpi]=-1;}
                        ni++;
                       // printf("ni=%d\n",ni);
                    }
                }
               //FIND0(temp);
            }
             FIND0(temp);
                if(length(temp)==0){
                    DFA[i].to[DL.ssm[k]][0]=-1;
                }
                else{
                    int ftp=FINDDFA(temp);
                    if(ftp!=-1){
                        DFA[i].to[DL.ssm[k]][0]=ftp;
                        DFA[i].to[DL.ssm[k]][1]=-1;
                        temp[0]=-1;
                    }
                    else {
                        DFA[i].to[DL.ssm[k]][0]=DL.dfanm;
                        DFA[i].to[DL.ssm[k]][1]=-1;
                        for(int i=0;i<=length(temp);i++)
                            {DFA[DL.dfanm].state[i]=temp[i];
                             DFA[DL.dfanm].state[i+1]=-1;
                            }
                        temp[0]=-1;
                        DL.dfanm++;
                    }
                }
        }


    }

    
    
}
void DFAWRITE(){
    printf("状态个数:%d\n",DL.dfanm);
    printf("字符表个数:%d\n状态转换:\n",length(DL.ssm));
    for(int i=0;i<DL.dfanm;i++){
        for(int k=0;k<length(DL.ssm);k++){
            if(DFA[i].to[DL.ssm[k]][0]!=-1){
                printf("(%d,%d)->%d\n",i,DL.ssm[k],DFA[i].to[DL.ssm[k]][0]);
            }
        }

    }
    int kaishi[100]={-1},jieshu[100]={-1},ks=0,js=0;
    for(int i=0;i<DL.dfanm;i++){
        for(int j=0;j<length(DFA[i].state);j++){
            if(isin(DL.beg,DFA[i].state[j])){
                kaishi[ks++]=i;kaishi[ks]=-1;
            }
            if(isin(DL.end,DFA[i].state[j])){
                jieshu[js++]=i;jieshu[js]=-1;
            }
        }
    }
    printf("开始集合:{");
    for(int i=0;i<length(kaishi);i++){
        if(i!=length(kaishi)-1)printf("%d,",kaishi[i]);
        else printf("%d}\n",kaishi[i]);
    }
    printf("结束集合:{");
    for(int i=0;i<length(jieshu);i++){
        if(i!=length(jieshu)-1)printf("%d,",jieshu[i]);
        else printf("%d}\n",jieshu[i]);
    }
}
int main(){
    NTODREAD(); NTODWRITE();//输入NFA
    NTOD();                 //NFA转换DFA
    DFAWRITE();             //输出DFA
    system("pause");
}

.禾火
关注
专栏目录
编译原理实验2——自动机的确定化和最小化
u011332631的专栏
12-06 9393
（前言：这个代码的产生真的是非常非常曲折。。。。 因为退役之后没事儿干，打算好好折腾ubuntu玩玩，结果装系统的时候把win装崩了，作业还没备份直接全没了。。 我重写的时候真的是眼里全是泪水。。。 后来实验报告写好了之后，又萌萌哒地没有备份，又留在机房一次= = 后来又是重写啊啊啊啊啊啊啊啊啊啊啊！） 使用说明： 调用NFA中的init函数可以对数组进行初始化。 调用NFA中的re
非确定有限自动机的确定化
12-26
编译原理的PPT，关于有限自动机的确定化的转化
不确定有穷自动机NFA的确定化
MeiGuiDaoLeHuaQi的博客
02-22 1585
不确定有穷自动机NFA的确定化，并用graphviz将输入的NFA和输出的DFA可视化
不确定有限状态自动机的确定化
06-05
不确定有限状态自动机的确定化，以及原理和源程序。
上机实验2-3有限自动机的确定化和最小化）1
08-08
实验的目标在于深入理解和应用有限自动机的理论，并通过编程实现自动机的确定化和最小化过程。 首先，我们要理解有限自动机的基本组成：状态、初始状态、终态集合、输入字母表和状态转移函数。状态是自动机的内部...
杭电编译原理实验——有限自动机的确定化和最小化
09-20
本实验“杭电编译原理实验——有限自动机的确定化和最小化”着重关注两种类型的有限自动机：确定有限自动机（Deterministic Finite Automaton, DFA）和非确定有限自动机（Non-Deterministic Finite Automaton, NFA）...
编译原理实验五：有穷自动机的确定化
12-13
确定化有穷自动机（Deterministic Finite Automaton，DFA）相对于非确定性有穷自动机（Nondeterministic Finite Automaton，NFA）具有明确的单路径性质，即对于任何输入字符串，DFA的执行过程只有一个确定的接受状态...
NFA转DFA 非确定有限自动机确定化（利用子集法构造DFA）
07-18
非确定有限自动机（Nondeterministic Finite Automaton，NFA）和确定有限自动机（Deterministic Finite Automaton，DFA）是计算理论中的两种重要概念，主要应用于形式语言和编译原理等领域。NFA是一种允许存在多种...
编译原理实验-不确定有穷状态自动机的确定化（NFA到DFA）
06-22
输入：非确定有穷状态自动机NFA 输出：确定化的有穷状态自动机DFA
有限状态自动机（NFA）的确定化
11-25
编译原理实验 输入有限（穷）状态自动机,输出确定化的有限（穷）状态自动机
不确定的有穷自动机的确定化
02-18
不确定有穷自动机转化为确定的有穷自动机的C++源代码
不确定的有穷自动机的确定化代码-（子集法）
izhouxiaofei的博客
05-12 3848
不确定的有穷自动机的确定化代码-（子集法）
C语言 确定有限状态自动机 DFA
fpk2014的博客
06-18 4487
确定有限状态自动机简介 实现过程 实现分析 代码实现 确定有限状态自动机简介 有限状态自动机拥有有限数量的状态，每个状态可以迁移到零个或多个状态，输入字串决定执行哪个状态的迁移。 DFA是理解KMP算法的基础。 关于什么是DFA，可参考链接：有穷自动机DFA&amp;NFA 本篇的主要目的是实现DFA。 实现过程 下面是一个字符串ABABAC的DF...
编译原理(二) NFA的确定化及DFA的最小化的算法及C++实现
热门推荐
llin-黎辰
11-12 1万+
1. NFA的确定化1.１. 明确NFA的定义一个非确定的有穷自动机(NFA)M是一个五元式： M=(S,∑,δ,S0,F)M=(S,\sum,\delta,S_0,F) S是一个有限集，它额每个元素称为一个状态。S是一个有限集，它额每个元素称为一个状态。 ∑是一个有穷字母表，它的每个元素称为一个输入字符\sum是一个有穷字母表，它的每个元素称为一个输入字符 δ是一个从S×∑∗至S子集额单值映射。
dfa确定有限自动机定义_确定性有限自动机（DFA）
07-21 6346
dfa确定有限自动机定义In Deterministic Finite Automata (DFA), for a given input symbol the machine will move to which next state can be determined and hence it is named as deterministic automata. The number of ...
由非确定自动机转为确定自动机的子集法
Susie_seven的小窝
04-14 1263
<br />第一步   先找初态的子集（ε-闭包) <br />第二步   找上面子集的所有经过某个输入符的新子集(ε-输入符闭包) <br />第三步   重复第二步，直到所有子集找完(必然)。 <br />第四步   将每个子集标一个号(即一种状态)，从一个号到另一个号为一个转换，画出这一系列号的转换图。 <br />第五步   包括原初态的子集是新的初态，包括原终态的子集为新的终集。 <br />完成 <br /><br />ε-闭包:指的是从某个状态出发，经过输入符为ε的路径所能到达的所有状态(包括
VScode中CMake无高亮（就是没有补全的提示）
最新发布
Moapsw033的博客
10-15 254
原因就是：本地没有配置环境变量，解决方法是下一个cmake然后直接配置环境变量。在我学的过程中我发现我的CMake是这样的，如下图。这非常的难受，所以疯狂的找，最后是CMake报错有。如何配置环境变量就直接上网找就好了，很简单的，加油。但在教学视频里是这样的（如下图）
有穷自动机确定化的原理
05-15
有穷自动机确定化的原理是将一个非确定性有穷自动机转换成一个确定性有穷自动机的过程。该过程的目的是消除非确定性，使得自动机的行为更加明确和可控。 转换过程主要分为以下几步： 1. 确定化的起点是一个非确定性有穷自动机(NFA)。 2. 创建一个新的状态集合Q'，其中每个状态表示原始NFA中的一个或多个状态的组合。 3. 将NFA的起始状态集合S作为DFA的起始状态。 4. 对于每个DFA状态集合Q'中的状态，以及对于每个输入符号，计算处理该输入符号后DFA将转移到哪个状态集合。 5. 重复步骤4，直到所有可能的状态集合都已经计算。 6. 最终得到一个新的确定性有穷自动机(DFA)，其中每个状态都唯一地表示一个状态集合。 确定化后的DFA可以更容易地进行分析和验证，并且可以有效地实现自动机的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值