不确定有穷自动机确定化编译原理实验报告.docx

不确定有穷自动机确定化编译原理实验报告.docx

《不确定有穷自动机确定化编译原理实验报告.docx》由会员分享，可在线阅读，更多相关《不确定有穷自动机确定化编译原理实验报告.docx（11页珍藏版）》请在冰豆网上搜索。

不确定有穷自动机确定化编译原理实验报告

不确定有穷自动机确定化编译原理实验报告

编译原理实验报告

实验名称

不确定有穷自动机的确定化

实验时间_____

20__年4月10日_______

院

系_______管理信息工程学院_______

班

级_______11计算机科学与技术____

学

号______202020219____________

姓

名________姜高__________________

1、、实验目的不确定有穷自动机的确定化

2、、实验原理用子集构造算法构造子集加入子集族中直到收敛（所有构造的子集都已存在于子集族）为止。

如原来不确定有穷自动机的五元组形式为：

M=（K，;，F，S，Z），其中K为状态集，;为字母表，F为转换函数，S为初始态，Z为终态集。

用子集族S代替K，新的转换函数D代替F，形成新的五元组M=（S，;，D，S，Z）即将原不确定有穷自动机转换为确定有穷自动机。

3、、实验内容

（1）

闭包计算：

closure（I）

（2）

转换函数：

move（I,a）

4、、伪伪代码

假定构造的子集族为S=（T1，T2。

。

。

。

。

。

），

K为状态集：

（1）

开始，令closure（K0）为S中唯一成员，并且未被标记

（2）

WHILE（C中存在尚未被标记的子集T）

DO{标记T;For每输入字母a

DO{U:

=closure（move（T,a））;IfU不在S中

then将U作为未被标记的子集加在S中

}}

5.

代码实现#include

#include

#defineMA_S100

usingnamespacestd;

stringNODE;//结点集合

stringCHANGE;//终结符集合

intN;//NFA边数

structedge{

stringfirst;

stringchange;

stringlast;

};

structchan{

stringltab;

stringjihe[MA_S];

};

voidkong（inta）

{

inti;

for（i=0;i

cout<<"";

}

//排序

voidpai_u（string;a）

{

inti,j;

charb;

for（j=0;j

for（i=0;i

if（NODE.find（a[i]）>NODE.find（a[i+1]））

{

b=a[i];

a[i]=a[i+1];

a[i+1]=b;

}

}

voideclouse（charc,string;he,edgeb[]）

{

intk;

for（k=0;k

{

if（c==b[k].first[0]）

if（b[k].change==“_”）

{

if（he.find（b[k].last）>he.length）

he+=b[k].last;

eclouse（b[k].last[0],he,b）;

}

}

}

voidmove（chan;he,intm,edgeb[]）

{

inti,j,k,l;

k=he.ltab.length;

l=he.jihe[m].length;

for（i=0;i

for（j=0;j

if（（CHANGE[m]==b[j].change[0]）;;（he.ltab[i]==b[j].first[0]））

if（he.jihe[m].find（b[j].last[0]）>he.jihe[m].length）

he.jihe[m]+=b[j].last[0];

for（i=0;i

for（j=0;j

if（（CHANGE[m]==b[j].change[0]）;;（he.jihe[m][i]==b[j].first[0]））

if（he.jihe[m].find（b[j].last[0]）>he.jihe[m].length）

he.jihe[m]+=b[j].last[0];

}

//输出

voidoutputfa（intlen,inth,chan_t）

{

inti,j,m;

cout<<“I”;

for（i=0;i

cout<<"I"<

cout<

for（i=0;i

{

cout<<""<

m=t[i].ltab.length;

for（j=0;j

{

kong（8-m）;

m=t[i].jihe[j].length;

cout<

}

cout<

}

}

voidmain

{

edge_b=newedge[MA_S];

inti,j,k,m,n,h,_,y,len;

boolflag;

stringjh[MA_S],endnode,ednode,sta;

cout<<“请输入NFA各边信息（起点条件[空为_]终点），以#结束：

”<

for（i=0;i

{

cin>>b[i].first;

if（b[i].first==“#”）break;

cin>>b[i].change>>b[i].last;

}

N=i;

/_for（j=0;j

cout<

for（i=0;i

{

if（NODE.find（b[i].first）>NODE.length）

NODE+=b[i].first;

if（NODE.find（b[i].last）>NODE.length）

NODE+=b[i].last;

if（（CHANGE.find（b[i].change）>CHANGE.length）;;（b[i].change!

=“_”））

CHANGE+=b[i].change;

}

len=CHANGE.length;

cout<<“结点中属于终态的是：

”<

cin>>endnode;

for（i=0;i

if（NODE.find（endnode[i]）>NODE.length）

{

cout<<“所输终态不在集合中，错误！

”<

return;

}

//cout<<“endnode=”<

chan_t=newchan[MA_S];

t[0].ltab=b[0].first;

h=1;

eclouse（b[0].first[0],t[0].ltab,b）;//求e-clouse

//cout<

for（i=0;i

{

for（j=0;j

for（m=0;m

eclouse（t[i].ltab[j],t[i].jihe[m],b）;//求e-clouse

for（k=0;k

{

//cout<”;

move（t[i],k,b）;//求move（I,a）

//cout<

for（j=0;j

eclouse（t[i].jihe[k][j],t[i].jihe[k],b）;//求e-clouse

}

for（j=0;j

{

pai_u（t[i].jihe[j]）;//对集合排序以便比较

for（k=0;k

{

flag=operator==（t[k].ltab,t[i].jihe[j]）;

if（flag）

break;

}

if（!

flag;;t[i].jihe[j].length）

t[h++].ltab=t[i].jihe[j];

}

}

cout<

”<

outputfa（len,h,t）;//输出状态转换矩阵

//状态重新命名

string_d=newstring[h];

NODE.erase;

cout<

”<

for（i=0;i

{

sta=t[i].ltab;

t[i].ltab.erase;

t[i].ltab="A"+i;

NODE+=t[i].ltab;

cout<<"{"<

for（j=0;j

if（sta.find（endnode[j]）

d[1]=ednode+=t[i].ltab;

for（k=0;k

for（m=0;m

if（sta==t[k].jihe[m]）

t[k].jihe[m]=t[i].ltab;

}

for（i=0;i

if（ednode.find（NODE[i]）>ednode.length）

d[0]+=NODE[i];

endnode=ednode;

cout<

”<

outputfa（len,h,t）;//输出DFA

cout<<“其中终态为：

”<

//DFA最小化

m=2;

sta.erase;

flag=0;

for（i=0;i

{

//cout<<“d[”<

for（k=0;k

{

//cout<<“I”<

y=m;

for（j=0;j

{

for（n=0;n

{

if（d[n].find（t[NODE.find（d[i][j]）].jihe[k]）

{

if（t[NODE.find（d[i][j]）].jihe[k].length==0）

_=m;

else

_=n;

if（!

sta.length）

{

sta+=_+48;

}

else

if（sta[0]!

=_+48）

{

d[m]+=d[i][j];

flag=1;

d[i].erase（j,1）;

//cout<

j--;

}

break;//跳出n

}

}//n

}//j

if（flag）

{

m++;

flag=0;

}

//cout<<“sta=”<

sta.erase;

}//k

}//i

cout<

”;

for（i=0;i

cout<<“{”<

cout<

//状态重新命名

chan_md=newchan[m];

NODE.erase;

cout<

”<

for（i=0;i

{

md[i].ltab="A"+i;

NODE+=md[i].ltab;

cout<<“{”<

}

for（i=0;i

for（k=0;k

for（j=0;j

{

if（d[i][0]==t[j].ltab[0]）

{

for（n=0;n

{

if（!

t[j].jihe[k].length）

break;

else

if（d[n].find（t[j].jihe[k]）

{

md[i].jihe[k]=md[n].ltab;

break;

}

}

break;

}

}

ednode.erase;

for（i=0;i

for（j=0;j

if（d[i].find（endnode[j]）

ednode+=md[i].ltab;

endnode=ednode;

cout<

”<

outputfa（len,m,md）;

cout<<“其中终态为：

”<

}