编译原理实验一——实现简单的DFA

//头文件 
#include <stdio.h>
#include <string>

//宏定义
#define MAX 100 
#define MAX1 1000
 
//变量定义 
int char_num;//字符集数目
char chars[MAX];//字符集
int state_num;//状态数目
int states[MAX];//状态集
int start_state;//初始状态编号
int accept_num;//接收状态集数目
char accepts[MAX];//接收状态集 
int transtable[MAX][MAX];//状态转移表
int states_num[MAX1];//记录状态在数组中的编号 

int testn;//测试用例编号 
FILE *f;//需要打开的文件 

int flag_check2_4[MAX];//0表示未访问过，1表示已经访问过 
//初始化设置为未访问过 
bool flag_dfa=false;//判断dfa是否合法的标记符

char road[MAX];//dfs记录之前的路径
int road_length=0;//dfs路径长度 

int le=0;//字符串的长度 


//写入函数，输入DFA五元组，并将五元组写入到.dfa文件中
void write();

//检查1:DFA存储情况
//输出：字符集，状态集，开始状态的编号，接收状态集，状态转换集 
void cheak1();

//检查2：DFA正确性检查
//检查所有集合的元素的唯一性。
//检查“开始状态”是否唯一，并是否包含在“状态集”中。
//检查“接收状态集”是否为空，并是否包含在“状态集”中。
//检查“状态转换表”是否满足DFA的要求。（是否能到达接收状态）
void check2();
bool check2_1();
bool check2_2();
bool check2_3();
void check2_4(int state);
//DFA的语言集列表显示：
//输入待显示的字符串的最大长度N，输出以上定义的DFA的语言集中长度≤N的所有规则字符串。 
void dfs(int state,int n);//尝试采用深度优先搜索dfs

//DFA的规则字符串判定：
//输入（或用字符集随机生成）一个字符串，模拟DFA识别字符串的过程判定该字符串是否是规则字符串（属于DFA的语言集）。
void judge(int state,char *l,int length);

int main()
{
	for(int i=0;i<MAX;i++) 
	flag_check2_4[i]=0;
	for(int i=0;i<MAX;i++)
	for(int j=0;j<MAX;j++)
	transtable[i][j]=-1;
	
	write();
	cheak1();
	check2();
	printf("请输入N：");
	int N;
	scanf("%d",&N);
	dfs(start_state,N);
	printf("----下面是判断字符串部分----\n");
	char a[1000]; 
	printf("请输入需要检测的字符串个数\n") ;
	int num;
	scanf("%d",&num) ;
	//循环输入判断字符串 
	for(int i=0;i<num;i++)
	{
	scanf("%s",&a);
	le=-1;
	while(a[++le]!=0);
	judge(start_state,a,le);	
	}
} 
 
void write()
{
	printf("请输入是第几个测试用例：");
	scanf("%d",&testn);
	switch(testn)//选择测试样例文件 
	{
		case 1:f=fopen("test1.dfa","rt+");break;//设置fopen函数，读写打开一个文本文件，允许读和写 
		case 2:f=fopen("test2.dfa","rt+");break;
		case 3:f=fopen("test3.dfa","rt+");break;
	}
	printf("请输入字符集个数：");
	scanf("%d",&char_num);
	fprintf(f,"%d\n",char_num);
	printf("请输入字符集：(请换行输入)\n");
	for(int i=0;i<char_num;i++)
	{
		fflush(stdin);
		//为什么会这样？？？？ 需要研究一下 
		scanf("%c",&chars[i]);
		fprintf(f,"%c ",chars[i]);
	}
	fprintf(f,"\n");
	printf("请输入状态集个数：");
	scanf("%d",&state_num);
	fprintf(f,"%d\n",state_num);
	printf("请输入状态集：");
	for(int i=0;i<state_num;i++)
	{
		scanf("%d",&states[i]);
		fprintf(f,"%d ",states[i]);
		states_num[states[i]]=i;
	}
	fprintf(f,"\n");
	printf("请输入开始状态：");
	scanf("%d",&start_state);
	fprintf(f,"%d\n",start_state);
	printf("请输入接受状态集个数：");
	scanf("%d",&accept_num);
	fprintf(f,"%d\n",accept_num);
	printf("请输入接受状态集：");
	for(int i=0;i<accept_num;i++) 
	{
		scanf("%d",&accepts[i]);
		fprintf(f,"%d ",accepts[i]);
	}
	fprintf(f,"\n");
	printf("请输入状态转换表：");
	for(int i=0;i<state_num;i++)
	{
		for(int j=0;j<char_num;j++)
		{
			scanf("%d",&transtable[i][j]);
			fprintf(f,"%d ",transtable[i][j]);
		}
		fprintf(f,"\n");	
	}
	printf("----下面是检测部分----\n"); 
}

void cheak1()
{
	printf("字符集数目：%d\n",char_num);
	printf("字符集：\n");
	for(int i=0;i<char_num;i++)
	    printf("%c ",chars[i]);
	printf("\n");
	printf("状态集数目：%d\n",state_num);
	printf("状态集：\n");
	for(int i=0;i<state_num;i++)
	    printf("%d ",states[i]); 
	printf("\n");
	printf("初始状态：%d\n",start_state);
	printf("接受状态集数目：%d\n",accept_num);
	printf("接受状态：\n");
	for(int i=0;i<accept_num;i++)
		printf("%d ",accepts[i]);
	printf("\n");
	printf("状态转移表:\n");
	for(int i=0;i<state_num;i++)
	{
		for(int j=0;j<char_num;j++)
		{
			printf("%d ",transtable[i][j]);
		}
		printf("\n");	
	}	
}

//检查所有元素集合的唯一性 
bool check2_1()
{
	//检查字符集合；
	bool flag1=true;
	for(int i=0;i<char_num;i++) 
	{
		for(int j=i+1;j<char_num;j++)
		{
			if(chars[i]==chars[j])
			flag1=false;
		}
	}
	if(flag1) printf("字符集合正确。\n");
	else printf("字符集合错误。\n"); 
	//检查状态集合；
	bool flag2=true;
	for(int i=0;i<state_num;i++) 
	{
		for(int j=i+1;j<state_num;j++)
		{
			if(states[i]==states[j])
			flag2=false;
		}
	}
	if(flag2) printf("状态集合正确。\n");
	else printf("状态集合错误。\n");  
	//接收状态集合；
	bool flag3=true;
	for(int i=0;i<accept_num;i++) 
	{
		for(int j=i+1;j<accept_num;j++)
		{
			if(accepts[i]==accepts[j])
			flag3=false;
		}
	}
	if(flag3) printf("接收集合正确。\n");
	else printf("接收集合错误。\n");   
	return flag1&flag2&flag3;//所有元素集合是否唯一 
} 

//检查“开始状态”是否唯一，并是否包含在“状态集”中。
bool check2_2()
{
	printf("开始状态唯一\n");
	bool flag=false;
	for(int i=0;i<state_num;i++)
	{
		if(start_state==states[i])
		flag=true;
	}
	if(flag) printf("开始状态包含在“状态集”中。\n");
	else printf("开始状态不包含在“状态集”中。\n"); 
	return flag;
}
 
//检查“接收状态集”是否为空，并是否包含在“状态集”中。
bool check2_3()
{
	printf("接收状态集不为空\n");
	int flags[accept_num];
	bool flag=true;
	for(int i=0;i<accept_num;i++)
	flags[i]=0;
	for(int i=0;i<accept_num;i++)
	{
		for(int j=0;j<state_num;j++)
		if(accepts[i]==states[j])
		flags[i]=1;
	}
	for(int i=0;i<accept_num;i++)
	{
		if(flags[i]==0) flag=false; 
	}
	if(flag)printf("接受状态都在状态集中\n");
	else printf("接受状态不全在状态集中\n");
	return flag;
}

//检查“状态转换表”是否满足DFA的要求。
//思路： 1. 是否是确定的（由输入可知肯定是确定的）
//2.检查能否到达接收状态集合 用DFS判断，从初始状态开始，如果能够到达接受状态集合则正确 
void check2_4(int state)
{
	flag_check2_4[state]=1;//该状态被访问过 
	bool flag=false;
	for(int i=0;i<accept_num;i++)
	{
		if(state==accepts[i])
		flag=true;
	}
	if(flag==true)
	flag_dfa=true; 
	else
	{
		for(int i=0;i<char_num;i++)
		{
			int state_=transtable[states_num[state]][i];
			if(state_!=-1&&flag_check2_4[state_]==0)
			check2_4(state_);
		 } 
	} 
}
 
void check2()
{
	check2_1();
	check2_2();
	check2_3();
	check2_4(start_state);
	if(flag_dfa) printf("DFA合理\n");
	else printf("DFA不合理\n");
	printf("----下面是显示语言集序列部分----\n");
	 
} 

void dfs(int state,int n)
{
	bool flag=false;
	for(int i=0;i<accept_num;i++)
	if(state==accepts[i])
	flag=true;
	if(flag)
	{
		for(int i=0;i<road_length;i++)
		{
			printf("%c",road[i]);
		}
		printf("\n"); 
	}
	if(n==0) return;
	for(int i=0;i<char_num;i++)
	{
		int state_=transtable[states_num[state]][i];
		if(state_!=-1)
		{
			road[road_length++]=chars[i];
			dfs(state_,n-1);
			road_length--;
		}
	}
 }
 
void judge(int state,char *l,int length)//判断最后一个字符是否是接收状态且中间的转移过程没有出错 
{
	bool flag=false;
	for(int i=0;i<accept_num;i++)
	if(state==accepts[i])
	    flag=true;//达到了接收状态 
	if(length==0&&flag)//到达了最后一个字符 
	{
		printf("正确\n");
		return ;
	} 
	else if(length==0&&!flag) 
	{
	    printf("错误\n");
		return ;
	}
	int char_=MAX-1;
	char cl=l[le-length];
	for(int i=0;i<char_num;i++)
	if(cl==chars[i])
	{
		char_=i;
		break;
	 } 	
	int state_=transtable[states_num[state]][char_];
	if(state_==-1)
	{
		printf("错误\n");
		return;
	}						
	judge(state_,l,--length);	
}