标签：
这里收集了sicily的陈炬桦老师编译原理实验课程的题目，曝上代码以供参考。
（如果这里的代码对您的思路有些许启发的话，请您点击一下推荐，给予作者写作的鼓励，不胜感谢！）
1-词法分析
题目1000：
1 1000. 词法分析程序设计 2 总提交数量： 183 通过数量： 138 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 设一语言的关键词、运算符、分界符的个数与单词如下： 7 struct { int number; string str[10]; } keywords={3,"int","main","return"} ; //关键词 8 struct { int number; string str[10]; } operators ={5,"+","*","=","+=","*="}; //运算符 9 struct { int number; string str[10]; } boundaries ={6,"(",")","{","}",",",";"} ; //分界符 10 struct { int number; string str[100];} identifieres={0}; //标识符 11 struct { int number; string str[100];} Unsigned_integer={0}; //无符号整数 12 以上类号分别为1~5，序号从0开始； 13 标识符是字母开头的字母数字串；常量为无符号整数； 14 用C++设计一程序实现词法分析。 15 16 输入格式 17 输入一程序，结束符用”#”； 18 19 输出格式 20 输出单词数对：<类号，序号>。 输出标识符表，用空格分隔； 输出无符号整数表，用空格分隔； 21 22 样例输入 23 将样例输入复制到剪贴板 24 main() 25 { int a=2,b=3; 26 return 2*b+a; 27 }# 28 样例输出 29 <1,1><3,0><3,1><3,2><1,0><4,0><2,2><5,0><3,4><4,1><2,2><5,1><3,5><1,2><5,0><2,1> 30 <4,1><2,0><4,0><3,5><3,3> 31 identifieres:a b 32 Unsigned_integer:2 3
AC代码：
1 #include <iostream> 2 #include <cstring> 3 using namespace std; 4 5 struct { int number; string str[10]; } keywords={3,"int","main","return"} ; //关键词 6 struct { int number; string str[10]; } operators ={5,"+","*","=","+=","*="}; //运算符 7 struct { int number; string str[10]; } boundaries ={6,"(",")","{","}",",",";"} ; //分界符 8 struct { int number; string str[100];} identifieres={0}; //标识符 9 struct { int number; string str[100];} Unsigned_integer={0}; //无符号整数 10 11 char k=0; 12 string st=""; 13 int main(){ 14 int i; char ch; bool nochar=1; 15 16 do{ 17 if(nochar)cin.get(ch); 18 if(ch==‘(‘){st+="<3,0>";nochar=1;} 19 else if(ch==‘)‘){ st+="<3,1>";nochar=1; } 20 else if(ch==‘{‘){ st+="<3,2>";nochar=1; } 21 else if(ch==‘}‘){ st+="<3,3>";nochar=1; } 22 else if(ch==‘,‘){ st+="<3,4>";nochar=1; } 23 else if(ch==‘;‘){ st+="<3,5>";nochar=1; } 24 else if(ch==‘+‘){ 25 cin.get(ch); 26 if(ch==‘=‘){ 27 st+="<2,3>";nochar=1; 28 } 29 else{ 30 st+="<2,0>";nochar=1; 31 } 32 } 33 else if(ch==‘*‘){ 34 cin.get(ch); 35 if(ch==‘=‘){ 36 st+="<2,4>";nochar=1; 37 } 38 else{ 39 st+="<2,1>";nochar=1; 40 } 41 } 42 else if(ch==‘=‘){ 43 st+="<2,2>";nochar=1; 44 } 45 else if(‘0‘<=ch&&ch<=‘9‘){ 46 string nstring=""; nochar=0; 47 do{ 48 nstring+=ch; 49 cin.get(ch); 50 } while(‘0‘<=ch&&ch<=‘9‘); 51 for(k=0;k<Unsigned_integer.number&&Unsigned_integer.str[k]!=nstring;k++ ); 52 53 if(k==Unsigned_integer.number ){ 54 Unsigned_integer.str[k] = nstring; 55 st+="<5,";st+=char(‘0‘+k); st+=">"; 56 Unsigned_integer.number++; 57 } 58 else{ 59 st+="<5,";st+=char(‘0‘+k);st+=">"; 60 } 61 } 62 else if(‘a‘<=ch&&ch<=‘z‘||‘A‘<=ch&&ch<=‘Z‘){ 63 string nstring="";nochar=0; 64 do{ 65 nstring+=ch; 66 cin.get(ch); 67 } while(‘a‘<=ch&&ch<=‘z‘||‘A‘<=ch&&ch<=‘Z‘) ; //读入关键字或者标示符的东西 68 69 for(k=0;k<= keywords.number &&keywords.str[k]!=nstring;k++ ); 70 if(k<keywords.number ){ 71 //测得输入字符是关键字之一 72 st+="<1,"; st+=char(‘0‘+k);st+=">"; 73 } 74 else{ 75 //测得输入字符不是关键字之一，而是标识符 76 for(k=0;k<identifieres.number && identifieres.str[k]!=nstring;k++ ); //检查是否是已经记录过的标识符 77 if(k==identifieres.number ){ //不是已经标识过的标识符 78 identifieres.str[k]=nstring; 79 st+="<4,";st=st+char(‘0‘+k);st+=">"; 80 identifieres.number++; 81 } 82 else{ 83 st+="<4,";st=st+char(‘0‘+k);st+=">"; 84 } 85 } 86 } 87 else nochar=1; 88 89 } while(ch!=‘#‘); 90 91 cout<<st<<endl; 92 cout<<"identifieres:"; 93 for(i=0;i<identifieres.number;i++ ){cout<<identifieres.str[i]<<" ";} cout<<endl; 94 cout<<"Unsigned_integer:"; 95 for(i=0;i<Unsigned_integer.number;i++ ){cout<<Unsigned_integer.str[i]<<" ";} cout<<endl; 96 97 return 0; 98 } 99
-----------------------------------
题目1001：
1 1001. 输入输出文法1 2 总提交数量： 95 通过数量： 53 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 7 8 设文法的非终结符，终结符，产生式为，开始符号为 9 struct { int Nv;string VN[10];} Vns={3,"E","T","F"}; 10 struct { int Nt;string VT[10];} Vts={7,"+","-","*","/","(",")","i"}; 11 struct { int Np;string PL[20],PR[20];} ps={0}; 12 string S="E"; 13 14 输入产生式的个数， 15 分别输入产生式的左边和右边符号 16 17 按非终结符顺序输出产生式 18 输入格式 19 8 20 E E+T 21 T T*F 22 E T 23 T F 24 F (E) 25 F i 26 E E-T 27 T T/F 28 29 输出格式 30 G[E]: 31 E::=E+T | T | E-T 32 T::=T*F | F | T/F 33 F::=(E) | i 34 35 样例输入 36 将样例输入复制到剪贴板 37 6 38 E E+T 39 T T*F 40 E T 41 T F 42 F (E) 43 F i 44 样例输出 45 G[E]: 46 E::=E+T | T 47 T::=T*F | F 48 F::=(E) | i
AC代码：
#include <iostream> #include <string> using namespace std; struct { int Nv;string VN[10];} Vns={3,"E","T","F"}; struct { int Nt;string VT[10];} Vts={7,"+","-","*","/","(",")","i"}; struct { int Np;string PL[20],PR[20];} ps={0}; string S="E"; int main(){ int num; cin>>num; num++; string temp; int k; string result[Vns.Nv]; while(num--){ getline(cin,temp); for(k=0;k<Vns.Nv;k++ ){ if(temp.substr(0,1)==Vns.VN[k] ) { result[k]+=temp.substr(2) + " | "; break; } } } for(k=0;k<Vns.Nv;k++){ result[k] = result[k].substr(0,result[k].length()-3 ); } cout<<"G["<<S<<"]:\n"; for(k=0;k<Vns.Nv;k++){ cout<<Vns.VN[k]<<"::="<<result[k]<<endl; } }
-----------------------------------
题目1002：
1 1002. 输入输出文法2 2 总提交数量： 76 通过数量： 53 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入开始符号，非终结符，终结符，产生式 7 按非终结符顺序输出产生式； 8 9 输入格式 10 输入开始符号； 11 非终结符个数，非终结符，空格符分隔； 12 终结符个数，终结符，空格符分隔； 13 产生式的个数，各产生式的左边和右边符号，空格符分隔； 14 15 输出格式 16 G[开始符号]： 17 按非终结符顺序输出各产生式； 18 19 样例输入 20 将样例输入复制到剪贴板 21 Z 22 8 Z E F P G T Q S 23 3 + * i 24 18 25 Z E+T 26 E E 27 P G 28 F F 29 P G 30 G G 31 T T*i 32 Q E 33 S i 34 E S+F 35 F FP 36 G GG 37 Q E+F 38 E T 39 F P 40 G F 41 Q T 42 Q S 43 样例输出 44 G[Z]: 45 Z::=E+T 46 E::=E | S+F | T 47 F::=F | FP | P 48 P::=G | G 49 G::=G | GG | F 50 T::=T*i 51 Q::=E | E+F | T | S 52 S::=i
AC代码：
1 #include <iostream> 2 #include <string> 3 #include <stdlib.h> 4 using namespace std; 5 6 struct { int Nv;string VN[10];} Vns={0}; 7 struct { int Nt;string VT[10];} Vts={0}; 8 struct { int Np;string PL[20],PR[20];} ps={0}; 9 string S=""; 10 11 int main(){ 12 cin>>S; 13 cin>>Vns.Nv ; 14 for(int i=0;i<Vns.Nv;i++ ){ 15 cin>>Vns.VN[i]; 16 } 17 18 cin>>Vts.Nt ; 19 for(int i=0;i<Vts.Nt;i++ ){ 20 cin>>Vts.VT[i] ; 21 } 22 23 int num; cin>>num; num++; 24 string temp; int k; 25 string result[Vns.Nv]; 26 while(num--){ 27 getline(cin,temp); 28 for(k=0;k<Vns.Nv;k++ ){ 29 if(temp.substr(0,1)==Vns.VN[k] ) { 30 result[k]+=temp.substr(2) + " | "; 31 break; 32 } 33 } 34 } 35 for(k=0;k<Vns.Nv;k++){ 36 result[k] = result[k].substr(0,result[k].length()-3 ); 37 } 38 39 cout<<"G["<<S<<"]:\n"; 40 for(k=0;k<Vns.Nv;k++){ 41 cout<<Vns.VN[k]<<"::="<<result[k]<<endl; 42 } 43 }
----------------------------------
题目1003：
1 1003. 输入文法压缩自产生式文法和不可达文法 2 总提交数量： 122 通过数量： 59 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入开始符号，非终结符，终结符，产生式 7 压缩自产生式文法和不可达文法后，按非终结符顺序输出产生式； 8 9 输入格式 10 11 输入开始符号； 12 非终结符个数，非终结符，空格符分隔； 13 终结符个数，终结符，空格符分隔； 14 产生式的个数，各产生式的左边和右边符号，空格符分隔； 15 16 输出格式 17 18 delete self production:自产生式文法 19 unreached Vn:不可达非终结符 20 delete production:不可达产生式 21 delete VN:不可达非终结符 22 G[开始符号]： 23 压缩自产生式文法和不可达文法后，按非终结符顺序输出各产生式； 24 25 样例输入 26 将样例输入复制到剪贴板 27 Z 28 8 Z E F P G T Q S 29 3 + * i 30 18 31 Z E+T 32 E E 33 P G 34 F F 35 P G 36 G G 37 T T*i 38 Q E 39 S i 40 E S+F 41 F FP 42 G GG 43 Q E+F 44 E T 45 F P 46 G F 47 Q T 48 Q S 49 样例输出 50 delete self production:E::=E 51 delete self production:F::=F 52 delete self production:G::=G 53 unreached Vn:Q 54 delete production:Q::=E 55 delete production:Q::=E+F 56 delete production:Q::=T 57 delete production:Q::=S 58 delete VN:Q 59 G[Z]: 60 Z::=E+T 61 E::=S+F | T 62 F::=FP | P 63 P::=G | G 64 G::=GG | F 65 T::=T*i 66 S::=i
AC代码：
1 #include <iostream> 2 #include <string> 3 #include <stdlib.h> 4 using namespace std; 5 6 struct { int Nv;string VN[10];bool get[10]; string result[10]; } Vns={0}; //非终结符 7 struct { int Nt;string VT[10];} Vts={0}; //终结符 8 struct { int Np;string PL[20],PR[20];} ps={0}; //产生式 9 struct { int Nu;string HH[10]; } unstr={0}; //记录自产生式 10 string S=""; //开始符号 11 12 void cinVns(); //输入非终结符 13 void cinVts(); //输入终结符 14 void cinps(); //输入产生式 15 void print(); //输出程序处理结果 16 17 int main(){ 18 cin>>S; //输入开始符号 19 cinVns(); //输入非终结符 20 cinVts(); //输入终结符 21 cinps(); //输入产生式 22 23 //筛除自产生式 24 unstr.Nu = 0; 25 for(int i=0;i<ps.Np;i++){ 26 if(ps.PL[i] == ps.PR[i]){ 27 unstr.HH[unstr.Nu ] = ""+ps.PL[i]+"::="+ps.PR[i]+""; 28 ps.PL[i]=ps.PR[i]="#"; 29 unstr.Nu++; 30 } 31 } 32 33 //筛除无“输入源”的非终结符 ,经过这个过程所有产生式中右侧出现过的非终结符都被标识为get=1 34 for(int i=0;i<Vns.Nv;i++){ 35 for(int j=0;j<ps.Np;j++){ 36 if( Vns.VN[i] ==ps.PR[j] ) { //只要有右侧等于左侧，那么久说这个“左侧”非终结符有源 37 Vns.get[i] = 1; 38 break; 39 } 40 } 41 if(Vns.VN[i]==S ) Vns.get[i] = 1; // 排除第一行z的影响 42 } 43 44 //得到输出结果产生式 45 for( int i=0;i<ps.Np;i++ ){ 46 for(int j=0;j<Vns.Nv;j++ ){ 47 if(ps.PL[i]==Vns.VN[j]&& ps.PL[i]!="#" ) 48 { 49 Vns.result[j] += ps.PR[i] +" | "; 50 } 51 } 52 } 53 54 print(); 55 56 } 57 58 void print(){ 59 for(int i=0;i<unstr.Nu;i++){ 60 cout<<"delete self production:"<<unstr.HH[i]<<endl; 61 } 62 63 cout<<"unreached Vn:"; 64 for(int i=0;i<Vns.Nv;i++){ 65 if(!Vns.get[i]){ 66 cout<<Vns.VN[i]; 67 } 68 } 69 cout<<endl; 70 71 for(int i=0;i<Vns.Nv;i++){ 72 if(!Vns.get[i]){ 73 for(int j=0;j<ps.Np;j++){ 74 if(ps.PL[j]==Vns.VN[i]){ 75 cout<<"delete production:"<<ps.PL[j]<<"::="<<ps.PR[j]<<endl; 76 } 77 } 78 } 79 } 80 81 cout<<"delete VN:"; 82 for(int i=0;i<Vns.Nv;i++){ 83 if(!Vns.get[i]){ 84 cout<<Vns.VN[i]; 85 } 86 } 87 cout<<endl; 88 89 cout<<"G["<<S<<"]:"<<endl; 90 for(int i=0;i<Vns.Nv;i++){ 91 if(Vns.get[i]){ 92 cout<<Vns.VN[i]<<"::="<<Vns.result[i].substr(0,Vns.result[i].length()-3 )<<endl; 93 } 94 } 95 96 return ; 97 } 98 99 void cinps(){ 100 cin>>ps.Np; 101 for(int i=0;i<ps.Np;i++){ 102 cin>>ps.PL[i]>>ps.PR[i]; 103 } 104 return ; 105 } 106 107 void cinVns(){ 108 cin>>Vns.Nv ; //非终结符的个数 109 for(int i=0;i<Vns.Nv;i++ ){ //输入非终结符、空格符分隔 110 cin>>Vns.VN[i]; 111 Vns.get[i] = 0; //初始化为：没有输入源 get[i] = 0 112 } 113 return; 114 } 115 116 void cinVts(){ 117 cin>>Vts.Nt ; //终结符个数 118 for(int i=0;i<Vts.Nt;i++ ){ //终结符 119 cin>>Vts.VT[i] ; //空格符分隔 120 } 121 return ; 122 }
------------------------------------
题目1004：
1 1004. 压缩自产生式,不可达非终结符和无用非终结符的产生式 2 总提交数量： 70 通过数量： 33 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入开始符号，非终结符，终结符，产生式 压缩自产生式文法，不可达文法和无用文法后，按非终结符顺序输出产生式； 7 8 输入格式 9 输入开始符号； 非终结符个数，非终结符，空格符分隔； 终结符个数，终结符，空格符分隔； 产生式的个数，各产生式的左边和右边符号，空格符分隔； 10 11 输出格式 12 delete self production:自产生式文法 unreached Vn:不可达非终结符 delete production:不可达产生式 delete VN:不可达非终结符 unusefulNv:无用非终结符 G[开始符号]： 压缩自产生式文法和不可达文法后，按非终结符顺序输出各产生式； 13 14 样例输入 15 将样例输入复制到剪贴板 16 Z 17 8 Z E F P G T Q S 18 3 + * i 19 18 20 Z E+T 21 E E 22 F F 23 P G 24 G G 25 T T*i 26 Q E 27 S i 28 E S+F 29 F FP 30 G GG 31 T i 32 Q E+F 33 E T 34 F P 35 G F 36 Q T 37 Q S 38 样例输出 39 delete self production:E::=E 40 delete self production:F::=F 41 delete self production:G::=G 42 unreached Vn:Q 43 delete VN:Q 44 delete production:Q::=E 45 delete production:Q::=E+F 46 delete production:Q::=T 47 delete production:Q::=S 48 unusefulNv:G 49 delete VN:G 50 delete production:P::=G 51 delete production:G::=GG 52 delete production:G::=F 53 unusefulNv:P 54 delete VN:P 55 delete production:F::=FP 56 delete production:F::=P 57 unusefulNv:F 58 delete VN:F 59 delete production:E::=S+F 60 unreached Vn:S 61 delete VN:S 62 delete production:S::=i 63 G[Z]: 64 Z::=E+T 65 E::=T 66 T::=T*i | i
AC代码：
1 #include <iostream> 2 #include <string> 3 #include <stdlib.h> 4 using namespace std; 5 6 string S=""; //开始符号 7 struct { int number;string sign[20]; bool get[20];bool enable[20]; string result[20]; } not_endsign={0}; //非终结符 8 struct { int number;string sign[20];} end_sign={0}; //终结符 9 struct { int number;string left[100],right[100];bool enable[100] ; } production={0}; //产生式 10 11 struct { int number;string sign[20];bool exit[20]; string result[20] ;} out={0}; 12 13 void input(); //输入开始符号、非终结符、终结符、产生式 14 void print(); //打印结果 15 bool into(string a,string b); 16 bool reachable(string test); 17 bool reach(string test); 18 bool ceyan(); 19 20 int main(){ 21 input(); 22 for(int i=0;i<production.number;i++ ){ 23 if(production.left[i]==production.right[i]){ 24 production.enable[i] = 0; 25 cout<<"delete self production:"<<production.left[i]<<"::="<<production.right[i]<<endl; 26 } 27 } 28 29 for(int i=0;i<not_endsign.number;i++){ 30 for(int j=0;j<production.number;j++){ 31 if(not_endsign.sign[i]==production.left[j]&&production.enable[j] ){ 32 not_endsign.result[i]+=production.right[j]+" | "; 33 } 34 } 35 if(S==not_endsign.sign[i] ) not_endsign.enable[i] = 0; 36 } 37 38 for(int i=0;i<not_endsign.number;i++){ 39 if(S == not_endsign.sign[i]) not_endsign.enable[i] = 0; 40 } 41 42 bool xunhuan = 1; 43 while(xunhuan ){ 44 //每循环一次检查一次“不可达非终结符” 45 xunhuan = 0; 46 for(int i=not_endsign.number-1;i>=0;i-- ){ 47 if(not_endsign.enable[i] && !reachable(not_endsign.sign[i]) ){ 48 not_endsign.enable[i] = 0; 49 cout<<"unreached Vn:"<<not_endsign.sign[i]<<endl; 50 cout<<"delete VN:"<<not_endsign.sign[i]<<endl; 51 xunhuan = 1; 52 for(int j=0;j<production.number;j++ ){ 53 if(into(not_endsign.sign[i],production.left[j] )|| into(not_endsign.sign[i],production.right[j] ) ){ 54 if(production.enable[j]) { 55 production.enable[j] = 0; 56 cout<<"delete production:"<<production.left[j]<<"::="<<production.right[j]<<endl; 57 } 58 59 } 60 } 61 62 } 63 } 64 65 //每次循环一次检查一次“不可用非终结符” 66 for(int i=not_endsign.number-1;i>=0;i-- ){ 67 bool det = 0; 68 for(int j=0;j< not_endsign.result[i].length();j++ ){ 69 if(reach (not_endsign.result[i].substr(j,1)) ) det = 1; 70 } 71 72 if(!det&¬_endsign.enable[i]==1){ 73 xunhuan = 1; 74 not_endsign.enable[i] = 0; 75 cout<<"unusefulNv:"<<not_endsign.sign[i]<<endl; 76 cout<<"delete VN:"<<not_endsign.sign[i]<<endl; 77 for(int j=0;j<production.number;j++ ){ 78 if(into(not_endsign.sign[i],production.left[j] )|| into(not_endsign.sign[i],production.right[j] ) ){ 79 if(production.enable[j]) { 80 production.enable[j] = 0; 81 cout<<"delete production:"<<production.left[j]<<"::="<<production.right[j]<<endl; 82 } 83 } 84 } 85 } 86 } 87 88 } 89 90 print(); 91 return 0; 92 } 93 94 //测试test中是否有终结符 95 bool reach(string test){ 96 for(int i=0;i<end_sign.number;i++){ 97 if(test==end_sign.sign[i]) return 1; 98 } 99 return 0; 100 } 101 102 //测试test是否可达 103 bool reachable(string test){ 104 for(int i=0;i<production.number;i++){ 105 if(production.enable[i] &&into(test,production.right[i] ) ) return 1; 106 } 107 return 0; 108 } 109 110 bool into(string a,string b){ 111 //a是待测试的非终结符，单字符，即产生式左边的部分 112 for(int i=0;i<b.size();i++){ 113 if(a==b.substr(i,1) ) return 1; 114 } 115 return 0; 116 } 117 118 void print(){ 119 cout<<"G["<<S<<"]:\n"; 120 for(int i=0;i<not_endsign.number;i++ ){ 121 out.exit[out.number] = 0; 122 out.sign[out.number++ ] = not_endsign.sign[i]; 123 124 } 125 126 for(int i=0;i<production.number;i++){ 127 for(int j=0;j<out.number;j++){ 128 if(production.enable[i]){ 129 if(production.left[i]==out.sign[j] ){ 130 out.result[j]+=production.right[i]+" | "; 131 out.exit[j] = 1; 132 } 133 } 134 } 135 } 136 137 for(int i=0;i<out.number;i++){ 138 if(out.exit[i]){ 139 cout<<out.sign[i]<<"::="<<out.result[i].substr(0,out.result[i].length()-3 )<<endl; 140 } 141 } 142 143 return ; 144 } 145 146 void input(){ 147 //输入开始符号 148 cin>>S; 149 150 //输入非终结符 151 cin>>not_endsign.number; 152 for(int i=0;i<not_endsign.number;i++ ){ 153 cin>>not_endsign.sign[i]; 154 not_endsign.get[i] = 0; //说明非终结符没有输入源 155 not_endsign.enable[i] = 1; //说明非终结符现在还可用，还没被删除 156 } 157 158 //输入终结符 159 cin>>end_sign.number; 160 for(int j=0;j<end_sign.number;j++ ){ 161 cin>>end_sign.sign[j]; 162 } 163 164 //输入产生式 165 cin>>production.number; 166 for(int z=0;z<production.number;z++){ 167 cin>>production.left[z]>>production.right[z]; 168 production.enable[z] = 1; //说明该产生式还可用，还没被删除 169 } 170 return ; 171 }
------------------------------------
题目1005：
1 1005. NDFA 确定化 2 总提交数量： 53 通过数量： 29 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入字母表，非确定ＦＡ状态集，映射集；用造表法算法。 7 输出确定ＦＡ状态集，映射集； 8 9 输入格式 10 输入字母个数，字母表 11 状态个数，状态表（状态名称，开始状态，终止状态：0否1是），空格符分隔； 12 映射个数，映射表（起，终，字母），空格符分隔； 13 【参考作业3.4】 14 15 输出格式 16 Determine State: 17 状态表: 状态名称，开始状态，终止状态，[子集] 18 Determine Mapping: 19 映射表: 起，终，字母,(顺序号 20 21 样例输入 22 将样例输入复制到剪贴板 23 2 24 x y 25 5 26 0 1 0 27 1 0 0 28 2 0 0 29 3 0 0 30 4 0 1 31 9 32 0 1 x 33 0 2 y 34 1 2 x 35 1 3 x 36 2 1 y 37 2 3 y 38 3 3 x 39 3 3 y 40 3 4 x 41 样例输出 42 Determine State: 43 0 1 0 [0] 44 1 0 0 [1] 45 2 0 0 [2] 46 3 0 0 [23] 47 4 0 0 [13] 48 5 0 1 [34] 49 6 0 1 [234] 50 7 0 0 [3] 51 Determine Mapping: 52 0 1 x (0 53 0 2 y (1 54 1 3 x (2 55 2 4 y (3 56 3 5 x (4 57 3 4 y (5 58 4 6 x (6 59 4 7 y (7 60 5 5 x (8 61 5 7 y (9 62 6 5 x (10 63 6 4 y (11 64 7 5 x (12 65 7 7 y (13
AC代码：
1 #include <iostream> 2 #include <queue> 3 #include <stdlib.h> 4 #include <string> 5 #include <sstream> 6 using namespace std; 7 8 struct { int number; char zimu[100]; } letter={0}; //字母 9 struct { int number; int single_state[100];bool isstart[100];bool isend[100]; } state={0}; //状态表 10 struct { int number; int start[100]; int end[100]; char letter[100]; } map={0}; //映射表 11 12 struct { int number; int res_state[100]; bool isstart[100];bool isend[100];string chuan[100]; } ressta={0}; //确定化后的状态表 13 struct { int number; int start[100]; int end[100]; char letter[100]; } resmap={0}; //确定化后的映射表 14 15 struct ss{ int number; int ber[100]; bool isstart;bool isend; }; 16 queue<ss> temp; //用来 缓存造表法中的元素 17 struct { int number; string left[100];string right[100];char zimu[100];} haha={0}; //用来暂时记录string状态的映射关系 18 19 void input(); //输入数据 20 void print(); //输出结果 21 void init(); //初始化 22 string int2string(int a); 23 string change(ss teres); 24 bool isexist(ss a); 25 bool isexist_start( ss a ); 26 bool isexist_end(ss a); 27 28 int main(){ 29 input(); 30 init(); 31 while(1){ 32 ss te = temp.front(); temp.pop(); 33 34 //刷整个映射表，得到确定化后的状态表 ，并将确定化后的映射记录在表中 35 for(int i=0; i< letter.number; i++ ){ //字母 36 ss teres; //用来缓存将要压入队列的状态 37 teres.number = 0; 38 39 for(int j=0;j< te.number ;j++){ 40 for(int z=0;z<map.number ;z++){ 41 if( letter.zimu[i] == map.letter[z]&& te.ber[j]==map.start[z] ){ 42 bool is=1; 43 for(int q=0;q<teres.number;q++){ 44 if(map.end[z]==teres.ber[q] ) is = 0; 45 } 46 47 if(is){ 48 teres.ber[teres.number ] = map.end[z]; 49 teres.number++; 50 } 51 } 52 } 53 } 54 55 //对teres做“确定化后状态表”处理 56 if(!isexist(teres)){ 57 temp.push(teres); //压到temp里面 58 59 ressta.res_state[ ressta.number ] = ressta.number; 60 ressta.chuan[ressta.number] = change(teres); 61 if( isexist_start(teres) ){ 62 ressta.isstart[ressta.number] = 1; 63 } 64 else{ 65 ressta.isstart[ressta.number] = 0; 66 } 67 68 if( isexist_end(teres)){ 69 ressta.isend[ressta.number] = 1; 70 } 71 else{ 72 ressta.isend[ressta.number] = 0; 73 } 74 75 ressta.number++; 76 } 77 78 //还有映射表 79 if(teres.number!=0){ 80 haha.left[haha.number ] = change(te); 81 haha.right[haha.number] = change(teres); 82 haha.zimu[haha.number] = letter.zimu[i]; 83 haha.number++; 84 } 85 86 } 87 88 if(temp.empty()) break; 89 } 90 91 for(int i=0;i<haha.number;i++){ 92 int k; 93 for(k=0; k<ressta.number&&ressta.chuan[k] != haha.left[i]; k++ ) ; 94 resmap.start[resmap.number] = ressta.res_state[k]; 95 96 int p; 97 for(p=0;p<ressta.number&&ressta.chuan[p]!=haha.right[i];p++ ); 98 resmap.end[resmap.number ] = ressta.res_state[p]; 99 100 resmap.letter[resmap.number] = haha.zimu[i]; 101 102 resmap.number++; 103 } 104 105 print(); 106 return 0; 107 } 108 109 void init(){ 110 ressta.number = 0; 111 112 ss first; 113 first.number = 1; 114 first.isstart = state.isstart[0]; 115 first.isend = state.isend[0]; 116 first.ber[0] = state.single_state[0]; 117 temp.push(first); 118 119 //相当于把 temp队列中的第一个元素记入 “确定化后的状态集” 120 ressta.res_state[0] = state.single_state[0]; 121 ressta.isstart[0] = state.isstart[0]; 122 ressta.isend[0] = state.isend[0]; 123 ressta.chuan[0] = int2string( state.single_state[0] ); 124 125 ressta.number++; 126 127 return ; 128 } 129 130 bool isexist_start( ss a ){ 131 for(int i=0;i<a.number;i++){ 132 for(int j=0;j<state.number;j++ ){ 133 if(state.isstart[j]==1&&a.ber[i]==state.single_state[j] ) return true; 134 } 135 } 136 return false; 137 } 138 139 bool isexist_end(ss a){ 140 for(int i=0;i<a.number;i++){ 141 for(int j=0;j<state.number;j++ ){ 142 if(state.isend[j]==1&&a.ber[i]==state.single_state[j] ) return true; 143 } 144 } 145 return false; 146 } 147 148 bool isexist(ss a){ 149 if(a.number==0) return 1; 150 for(int i=0;i<ressta.number;i++){ 151 if(ressta.chuan[i]==change(a) ){ 152 return 1; 153 } 154 } 155 return 0; 156 } 157 158 159 string int2string(int a){ 160 stringstream ss; 161 string str; 162 ss<<a; 163 ss>>str; 164 return str; 165 } 166 167 string change( ss teres){ 168 string res; 169 for(int i=0;i<teres.number;i++ ){ 170 res = res + int2string( teres.ber[i] ); 171 } 172 return res; 173 } 174 175 void input(){ 176 cin>>letter.number; 177 for(int i=0;i<letter.number;i++){ 178 cin>>letter.zimu[i]; 179 } 180 cin>>state.number; 181 for(int i=0;i<state.number;i++){ 182 cin>>state.single_state[i]>>state.isstart[i]>>state.isend[i]; 183 } 184 cin>>map.number; 185 for(int i=0;i<map.number;i++){ 186 cin>>map.start[i]>>map.end[i]>>map.letter[i]; 187 } 188 return ; 189 } 190 191 void print(){ 192 cout<<"Determine State:"<<endl; 193 for(int i=0;i<ressta.number;i++){ 194 cout<<ressta.res_state[i]<<" "<<ressta.isstart[i]<<" "<<ressta.isend[i]<<" ["<<ressta.chuan[i]<<"]"<<endl; 195 } 196 197 cout<<"Determine Mapping:"<<endl; 198 for(int i=0;i<resmap.number;i++){ 199 cout<<resmap.start[i]<<" "<<resmap.end[i]<<" "<<resmap.letter[i]<<" ("<<i<<endl; 200 } 201 202 return ; 203 }
------------------------------------
题目1006：
1 1006. εNDFA 确定化 2 总提交数量： 50 通过数量： 29 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入字母表，非确定εNDFA 确定化ＦＡ状态集，映射集；用造表法算法。 7 输出确定ＦＡ状态集，映射集； 8 9 输入格式 10 输入字母个数，字母表 11 状态个数，状态表（状态名称，开始状态，终止状态：0否1是），空格符分隔； 12 映射个数，映射表（起，终，字母），空格符分隔，k表示ε； 13 【参考作业3.2<1>】 14 15 输出格式 16 Determine State: 17 状态表: 状态名称，开始状态，终止状态，[子集] 18 Determine Mapping: 19 映射表: 起，终，字母,(顺序号 20 21 样例输入 22 将样例输入复制到剪贴板 23 2 24 x y 25 9 26 0 1 0 27 1 0 0 28 2 0 0 29 3 0 0 30 4 0 0 31 5 0 0 32 6 0 0 33 7 0 0 34 8 0 1 35 12 36 0 1 x 37 0 3 y 38 0 6 x 39 1 2 k 40 2 2 y 41 2 8 k 42 3 4 k 43 4 4 x 44 4 5 k 45 5 8 y 46 6 7 y 47 7 8 x 48 样例输出 49 Determine State: 50 0 1 0 [0] 51 1 0 1 [1268] 52 2 0 0 [345] 53 3 0 1 [278] 54 4 0 0 [45] 55 5 0 1 [8] 56 6 0 1 [28] 57 Determine Mapping: 58 0 1 x (0 59 0 2 y (1 60 1 3 y (2 61 2 4 x (3 62 2 5 y (4 63 3 5 x (5 64 3 6 y (6 65 4 4 x (7 66 4 5 y (8 67 6 6 y (9
AC代码：
1 #include <iostream> 2 #include <queue> 3 #include <stdlib.h> 4 #include <string> 5 #include <sstream> 6 using namespace std; 7 8 struct { int number; char zimu[100]; } letter={0}; //字母 9 struct { int number; int single_state[100];bool isstart[100];bool isend[100]; } state={0}; //状态表 10 struct { int number; int start[100]; int end[100]; char letter[100]; } map={0}; //映射表 11 12 struct { int number; int res_state[100]; bool isstart[100];bool isend[100];string chuan[100]; } ressta={0}; //确定化后的状态表 13 struct { int number; int start[100]; int end[100]; char letter[100]; } resmap={0}; //确定化后的映射表 14 15 struct ss{ int number; int ber[100]; bool isstart;bool isend; }; 16 queue<ss> temp; //用来 缓存造表法中的元素 17 struct { int number; string left[100];string right[100];char zimu[100];} haha={0}; //用来暂时记录string状态的映射关系 18 queue<int > letter_kong; //用来实现映射的 “深搜”的队列 19 20 void input(); //输入数据 21 void print(); //输出结果 22 void init(); //初始化 23 string int2string(int a); 24 string change(ss teres); 25 bool isexist(ss a); 26 bool isexist_start( ss a ); 27 bool isexist_end(ss a); 28 void sort(ss a); 29 30 int main(){ 31 input(); 32 init(); 33 34 while(1){ 35 ss te = temp.front(); temp.pop(); 36 37 //刷整个映射表，得到确定化后的状态表 ，并将确定化后的映射记录在表中 38 for(int i=0; i< letter.number; i++ ){ //字母 39 ss teres; //用来缓存将要压入队列的状态 40 teres.number = 0; 41 42 for(int j=0;j< te.number ;j++){ 43 for(int z=0;z<map.number ;z++){ 44 if( letter.zimu[i] == map.letter[z]&& te.ber[j]==map.start[z] ){ 45 bool is=1; 46 for(int q=0;q<teres.number;q++){ 47 if(map.end[z]==teres.ber[q] ) is = 0; 48 } 49 50 if(is){ 51 //先把确定的这个放进去 52 teres.ber[teres.number ] = map.end[z]; 53 teres.number++; 54 55 //处理有可能是空的需要深搜的情况 56 letter_kong.push( map.end[z] ); 57 while(1){ 58 int temp = letter_kong.front();letter_kong.pop(); 59 for(int r=0;r<map.number;r++ ){ 60 if(temp==map.start[r]&&map.letter[r]==‘k‘ ){ 61 //判断重复 62 bool iss=1; 63 for(int qq=0;qq<teres.number;qq++){ 64 if(map.end[r ]==teres.ber[qq] ) is = 0; 65 } 66 67 if(iss){ 68 teres.ber[teres.number ] = map.end[r]; 69 teres.number++; 70 letter_kong.push(map.end[r]); //将新的节点放进去 71 } 72 73 } 74 } 75 76 if(letter_kong.empty()) break; 77 } 78 79 80 81 // */ 82 83 } 84 } 85 } 86 } 87 88 //对teres中的元素按大小排序 89 int tempq; 90 for(int ii=0;ii<teres.number - 1;ii++ ){ 91 for(int jj=ii+1;jj<teres.number;jj++ ){ 92 if(teres.ber[jj]<teres.ber[ii] ){ 93 94 tempq = teres.ber[ii]; 95 teres.ber[ii] = teres.ber[jj]; 96 teres.ber[jj] = tempq; 97 } 98 } 99 } 100 101 //对teres做“确定化后状态表”处理 102 if(!isexist(teres)){ 103 temp.push(teres); //压到temp里面 104 105 ressta.res_state[ ressta.number ] = ressta.number; 106 ressta.chuan[ressta.number] = change(teres); 107 if( isexist_start(teres) ){ 108 ressta.isstart[ressta.number] = 1; 109 } 110 else{ 111 ressta.isstart[ressta.number] = 0; 112 } 113 114 if( isexist_end(teres)){ 115 ressta.isend[ressta.number] = 1; 116 } 117 else{ 118 ressta.isend[ressta.number] = 0; 119 } 120 121 ressta.number++; 122 } 123 124 //还有映射表 125 if(teres.number!=0){ 126 haha.left[haha.number ] = change(te); 127 haha.right[haha.number] = change(teres); 128 haha.zimu[haha.number] = letter.zimu[i]; 129 haha.number++; 130 } 131 132 } 133 134 if(temp.empty()) break; 135 } 136 137 for(int i=0;i<haha.number;i++){ 138 int k; 139 for(k=0; k<ressta.number&&ressta.chuan[k] != haha.left[i]; k++ ) ; 140 resmap.start[resmap.number] = ressta.res_state[k]; 141 142 int p; 143 for(p=0;p<ressta.number&&ressta.chuan[p]!=haha.right[i];p++ ); 144 resmap.end[resmap.number ] = ressta.res_state[p]; 145 146 resmap.letter[resmap.number] = haha.zimu[i]; 147 148 resmap.number++; 149 } 150 151 print(); 152 return 0; 153 } 154 155 void init(){ 156 ressta.number = 0; 157 158 ss first; 159 first.number = 1; 160 first.isstart = state.isstart[0]; 161 first.isend = state.isend[0]; 162 first.ber[0] = state.single_state[0]; 163 temp.push(first); 164 165 //相当于把 temp队列中的第一个元素记入 “确定化后的状态集” 166 ressta.res_state[0] = state.single_state[0]; 167 ressta.isstart[0] = state.isstart[0]; 168 ressta.isend[0] = state.isend[0]; 169 ressta.chuan[0] = int2string( state.single_state[0] ); 170 171 ressta.number++; 172 173 return ; 174 } 175 176 bool isexist_start( ss a ){ 177 for(int i=0;i<a.number;i++){ 178 for(int j=0;j<state.number;j++ ){ 179 if(state.isstart[j]==1&&a.ber[i]==state.single_state[j] ) return true; 180 } 181 } 182 return false; 183 } 184 185 bool isexist_end(ss a){ 186 for(int i=0;i<a.number;i++){ 187 for(int j=0;j<state.number;j++ ){ 188 if(state.isend[j]==1&&a.ber[i]==state.single_state[j] ) return true; 189 } 190 } 191 return false; 192 } 193 194 bool isexist(ss a){ 195 if(a.number==0) return 1; 196 for(int i=0;i<ressta.number;i++){ 197 if(ressta.chuan[i]==change(a) ){ 198 return 1; 199 } 200 } 201 return 0; 202 } 203 204 205 string int2string(int a){ 206 stringstream ss; 207 string str; 208 ss<<a; 209 ss>>str; 210 return str; 211 } 212 213 string change( ss teres){ 214 string res; 215 for(int i=0;i<teres.number;i++ ){ 216 res = res + int2string( teres.ber[i] ); 217 } 218 return res; 219 } 220 221 void input(){ 222 cin>>letter.number; 223 for(int i=0;i<letter.number;i++){ 224 cin>>letter.zimu[i]; 225 } 226 cin>>state.number; 227 for(int i=0;i<state.number;i++){ 228 cin>>state.single_state[i]>>state.isstart[i]>>state.isend[i]; 229 } 230 cin>>map.number; 231 for(int i=0;i<map.number;i++){ 232 cin>>map.start[i]>>map.end[i]>>map.letter[i]; 233 } 234 return ; 235 } 236 237 void print(){ 238 cout<<"Determine State:"<<endl; 239 for(int i=0;i<ressta.number;i++){ 240 cout<<ressta.res_state[i]<<" "<<ressta.isstart[i]<<" "<<ressta.isend[i]<<" ["<<ressta.chuan[i]<<"]"<<endl; 241 } 242 243 cout<<"Determine Mapping:"<<endl; 244 for(int i=0;i<resmap.number;i++){ 245 cout<<resmap.start[i]<<" "<<resmap.end[i]<<" "<<resmap.letter[i]<<" ("<<i<<endl; 246 } 247 248 return ; 249 }
2-自上而下语法分析
题目1000：
1 1000. 输入输出LL(1)语法分析程序 2 总提交数量： 57 通过数量： 30 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入开始符号，非终结符，终结符，产生式，LL(1)分析表 7 输出LL(1)分析表 8 9 G[E]:E →E+T | E-T | T 10 11 T →T*F | T/F | F 12 F →(E) | D 13 D →x | y | z 14 消除左递归G1[E]: 15 E →TA 16 A →+TA | -TA | e 17 T →FB 18 B →*FB | /FB | e 19 F →(E) | D 20 D →x | y | z 21 输入格式 22 输入开始符号； 23 非终结符个数，非终结符，空格符分隔； 24 终结符个数，终结符，空格符分隔； 25 产生式的个数，各产生式的序号，产生式的左边和右边符号，空格符分隔； 26 LL(1)分析表中的产生式个数，序号，行符号，列符号，产生式编号，空格符分隔； 27 28 输出格式 29 第一行：空，安终结符循序输出终结符，结束符‘#’，每个符号占5格； 30 其余行：非终结符符号，各对应终结符的产生式的右边，每个符号占5格； 31 32 样例输入 33 将样例输入复制到剪贴板 34 E 35 6 E A T B F D 36 9 + - * / ( ) x y z 37 13 38 1 E TA 39 2 A +TA 40 3 A -TA 41 4 A k 42 5 T FB 43 6 B *FB 44 7 B /FB 45 8 B k 46 9 F (E) 47 10 F D 48 11 D x 49 12 D y 50 13 D z 51 25 52 1 E ( 1 53 2 E x 1 54 3 E y 1 55 4 E z 1 56 5 A + 2 57 6 A - 3 58 7 A ) 4 59 8 A # 4 60 9 T ( 5 61 10 T x 5 62 11 T y 5 63 12 T z 5 64 13 B + 8 65 14 B - 8 66 15 B * 6 67 16 B / 7 68 17 B ) 8 69 18 B # 8 70 19 F ( 9 71 20 F x 10 72 21 F y 10 73 22 F z 10 74 23 D x 11 75 24 D y 12 76 25 D z 13 77 样例输出 78 + - * / ( ) x y z # 79 E TA TA TA TA 80 A +TA -TA k k 81 T FB FB FB FB 82 B k k *FB /FB k k 83 F (E) D D D 84 D x y z
AC代码：
1 #include <iostream> 2 using namespace std; 3 4 string S=""; //开始符号 5 struct { int number;string sign[20]; string res_LL[20][20]; } not_endsign={0}; //非终结符 6 struct { int number;string sign[20]; } end_sign={0}; //终结符 7 struct { int number;int order[100]; string left[100],right[100]; } production={0}; //产生式 8 struct { int number;int order[100]; string rank[100],col[100];int production_num[100]; } LL={0}; //LL(1)分析表 9 10 void input(); 11 void print(string a); 12 13 int main(){ 14 input(); 15 end_sign.sign[end_sign.number] = "#"; 16 end_sign.number++; 17 18 //刷整个的分析表，将分析表中的数据填入到not_endsign中去 19 for(int i=0;i<LL.number;i++){ 20 //得到LL一条数据的“行”对应的“非终结符” 21 int j; 22 for(j=0;j<not_endsign.number&& not_endsign.sign[j]!=LL.rank[i];j++ ); 23 24 //得到LL一条数据的“列”对应的“终结符” 25 int z; 26 for(z=0;z<end_sign.number&&end_sign.sign[z]!=LL.col[i];z++ ); 27 28 //得到LL一条数据的要赋予的值 29 not_endsign.res_LL[j][z] = production.right[LL.production_num[i]-1 ]; 30 } 31 32 //单独处理“#” 33 34 cout<<" "; 35 for(int i=0;i<end_sign.number;i++){ 36 cout<<" "<<end_sign.sign[i]; 37 } 38 cout<<endl; 39 40 for(int i=0;i<not_endsign.number;i++){ 41 print(not_endsign.sign[i]); 42 cout<<not_endsign.sign[i]; 43 for(int j=0;j<end_sign.number ;j++){ 44 print(not_endsign.res_LL[i][j] ); 45 cout<<not_endsign.res_LL[i][j]; 46 } 47 cout<<endl; 48 } 49 50 return 0; 51 } 52 53 void print(string a){ 54 for(int i=0;i<5-a.length();i++){ 55 cout<<" "; 56 } 57 return ; 58 } 59 void input(){ 60 cin>>S; 61 cin>>not_endsign.number; 62 for(int i=0;i<not_endsign.number;i++){ 63 cin>>not_endsign.sign[i]; 64 } 65 66 cin>>end_sign.number; 67 for(int i=0;i<end_sign.number;i++){ 68 cin>>end_sign.sign[i]; 69 } 70 71 cin>>production.number; 72 for(int i=0;i<production.number;i++){ 73 cin>>production.order[i]>>production.left[i]>>production.right[i]; 74 } 75 76 cin>>LL.number; 77 for(int i=0;i<LL.number;i++){ 78 cin>>LL.order[i]>>LL.rank[i]>>LL.col[i]>>LL.production_num[i]; 79 } 80 return ; 81 }
-----------------------------------------------
题目1001：
1 1001. 输入输出LL(1)语法分析程序 2 总提交数量： 55 通过数量： 37 3 4 时间限制：1秒 内存限制：256兆 5 题目描述 6 输入开始符号，非终结符，终结符，产生式，LL(1)分析表 7 输出LL(1)分析表 8 9 输入格式 10 输入开始符号； 11 非终结符个数，非终结符，空格符分隔； 12 终结符个数，终结符，空格符分隔； 13 产生式的个数，各产生式的序号，产生式的左边和右边符号，空格符分隔； 14 LL(1)分析表中的产生式个数，序号，行符号，列符号，产生式编号，空格符分隔； 15 输入一个算术式符号串，用#结束 16 17 输出格式 18 输出推导过程，每一步一行，中间“ & ”前是已经识别的子串，后是栈中信息。 19 20 样例输入 21 将样例输入复制到剪贴板 22 E 23 6 E A T B F D 24 9 + - * / ( ) x y z 25 13 26 1 E TA 27 2 A +TA 28 3 A -TA 29 4 A k 30 5 T FB 31 6 B *FB 32 7 B /FB 33 8 B k 34 9 F (E) 35 10 F D 36 11 D x 37 12 D y 38 13 D z 39 25 40 1 E ( 1 41 2 E x 1 42 3 E y 1 43 4 E z 1 44 5 A + 2 45 6 A - 3 46 7 A ) 4 47 8 A # 4 48 9 T ( 5 49 10 T x 5 50 11 T y 5 51 12 T z 5 52 13 B + 8 53 14 B - 8 54 15 B * 6 55 16 B / 7 56 17 B ) 8 57 18 B # 8 58 19 F ( 9 59 20 F x 10 60 21 F y 10 61 22 F z 10 62 23 D x 11 63 24 D y 12 64 25 D z 13 65 (x+(y-x*z)*(y+x*z))+x/z# 66 样例输出 67 # & E# 68 # & TA# 69 # & FBA# 70 # & (E)BA# 71 #( & E)BA# 72 #( & TA)BA# 73 #( & FBA)BA# 74 #( & DBA)BA# 75 #( & xBA)BA# 76 #(x & BA)BA# 77 #(x & A)BA# 78 #(x & +TA)BA# 79 #(x+ & TA)BA# 80 #(x+ & FBA)BA# 81 #(x+ & (E)BA)BA# 82 #(x+( & E)BA)BA# 83 #(x+( & TA)BA)BA# 84 #(x+( & FBA)BA)BA# 85 #(x+( & DBA)BA)BA# 86 #(x+( & yBA)BA)BA# 87 #(x+(y & BA)BA)BA# 88 #(x+(y & A)BA)BA# 89 #(x+(y & -TA)BA)BA# 90 #(x+(y- & TA)BA)BA# 91 #(x+(y- & FBA)BA)BA# 92 #(x+(y- & DBA)BA)BA# 93 #(x+(y- & xBA)BA)BA# 94 #(x+(y-x & BA)BA)BA# 95 #(x+(y-x & *FBA)BA)BA# 96 #(x+(y-x* & FBA)BA)BA# 97 #(x+(y-x* & DBA)BA)BA# 98 #(x+(y-x* & zBA)BA)BA# 99 #(x+(y-x*z & BA)BA)BA# 100 #(x+(y-x*z & A)BA)BA# 101 #(x+(y-x*z & )BA)BA# 102 #(x+(y-x*z) & BA)BA# 103 #(x+(y-x*z) & *FBA)BA# 104 #(x+(y-x*z)* & FBA)BA# 105 #(x+(y-x*z)* & (E)BA)BA# 106 #(x+(y-x*z)*( & E)BA)BA# 107 #(x+(y-x*z)*( & TA)BA)BA# 108 #(x+(y-x*z)*( & FBA)BA)BA# 109 #(x+(y-x*z)*( & DBA)BA)BA# 110 #(x+(y-x*z)*( & yBA)BA)BA# 111 #(x+(y-x*z)*(y & BA)BA)BA# 112 #(x+(y-x*z)*(y & A)BA)BA# 113 #(x+(y-x*z)*(y & +TA)BA)BA# 114 #(x+(y-x*z)*(y+ & TA)BA)BA# 115 #(x+(y-x*z)*(y+ & FBA)BA)BA# 116 #(x+(y-x*z)*(y+ & DBA)BA)BA# 117 #(x+(y-x*z)*(y+ & xBA)BA)BA# 118 #(x+(y-x*z)*(y+x & BA)BA)BA# 119 #(x+(y-x*z)*(y+x & *FBA)BA)BA# 120 #(x+(y-x*z)*(y+x* & FBA)BA)BA# 121 #(x+(y-x*z)*(y+x* & DBA)BA)BA# 122 #(x+(y-x*z)*(y+x* & zBA)BA)BA# 123 #(x+(y-x*z)*(y+x*z & BA)BA)BA# 124 #(x+(y-x*z)*(y+x*z & A)BA)BA# 125 #(x+(y-x*z)*(y+x*z & )BA)BA# 126 #(x+(y-x*z)*(y+x*z) & BA)BA# 127 #(x+(y-x*z)*(y+x*z) & A)BA# 128 #(x+(y-x*z)*(y+x*z) & )BA# 129 #(x+(y-x*z)*(y+x*z)) & BA# 130 #(x+(y-x*z)*(y+x*z)) & A# 131 #(x+(y-x*z)*(y+x*z)) & +TA# 132 #(x+(y-x*z)*(y+x*z))+ & TA# 133 #(x+(y-x*z)*(y+x*z))+ & FBA# 134 #(x+(y-x*z)*(y+x*z))+ & DBA# 135 #(x+(y-x*z)*(y+x*z))+ & xBA# 136 #(x+(y-x*z)*(y+x*z))+x & BA# 137 #(x+(y-x*z)*(y+x*z))+x & /FBA# 138 #(x+(y-x*z)*(y+x*z))+x/ & FBA# 139 #(x+(y-x*z)*(y+x*z))+x/ & DBA# 140 #(x+(y-x*z)*(y+x*z))+x/ & zBA# 141 #(x+(y-x*z)*(y+x*z))+x/z & BA# 142 #(x+(y-x*z)*(y+x*z))+x/z & A# 143 #(x+(y-x*z)*(y+x*z))+x/z & #
AC代码：
1 #include <iostream> 2 #include <stack> 3 using namespace std; 4 5 string S=""; //开始符号 6 struct { int number;string sign[20]; string res_LL[20][20]; } not_endsign={0}; //非终结符 7 struct { int number;string sign[20]; } end_sign={0}; //终结符 8 struct { int number;int order[100]; string left[100],right[100]; } production={0}; //产生式 9 struct { int number;int order[100]; string rank[100],col[100];int production_num[100]; } LL={0}; //LL(1)分析表 10 string test; 11 12 void input(); 13 void print(string left,stack<string > right); 14 15 int main(){ 16 input(); 17 18 //定义输出结果 19 string left; 20 stack<string > right; 21 22 right.push(S) ; 23 print(left,right); 24 25 while(!right.empty()){ 26 string top = right.top(); 27 string firstletter = test.substr(0,1); 28 if(top==firstletter){ 29 left += top; 30 test = test.substr(1,test.length()-1 ); 31 right.pop(); 32 print(left,right); 33 34 continue; 35 } 36 else { 37 //替换掉 top 38 for(int i=0;i<LL.number;i++){ 39 if(LL.rank[i]==top &&LL.col[i]==firstletter ){ 40 right.pop(); 41 string temp = production.right[LL.production_num[i]-1 ]; 42 if(temp=="k") continue; 43 while(temp.length()!=0){ 44 string temp0 = temp.substr( temp.length()-1,1); 45 right.push(temp0); 46 temp = temp.substr(0,temp.length()-1); 47 } 48 49 } 50 } 51 52 } 53 54 print(left,right); 55 } 56 57 return 0; 58 } 59 60 void print(string left,stack<string > right){ 61 cout<<"#"<<left<<" & "; 62 string temp=""; 63 while(!right.empty()){ 64 cout<<right.top(); 65 temp+=right.top(); 66 right.pop(); 67 } 68 cout<<"#"<<endl; 69 70 while(temp.length()!=0){ 71 string temp0 = temp.substr( temp.length()-1,1); 72 right.push(temp0); 73 temp = temp.substr(0,temp.length()-1); 74 } 75 76 return ; 77 } 78 79 void input(){ 80 cin>>S; 81 cin>>not_endsign.number; 82 for(int i=0;i<not_endsign.number;i++){ 83 cin>>not_endsign.sign[i]; 84 } 85 86 cin>>end_sign.number; 87 for(int i=0;i<end_sign.number;i++){ 88 cin>>end_sign.sign[i]; 89 } 90 91 cin>>production.number; 92 for(int i=0;i<production.number;i++){ 93 cin>>production.order[i]>>production.left[i]>>production.right[i]; 94 } 95 96 cin>>LL.number; 97 for(int i=0;i<LL.number;i++){ 98 cin>>LL.order[i]>>LL.rank[i]>>LL.col[i]>>LL.production_num[i]; 99 } 100 101 cin>>test; 102 return ; 103 }
3-优先法语法分析
标签：
原文地址：http://www.cnblogs.com/liugl7/p/5501935.html
