构造识别规范句型活前缀DFA的源代…

最新推荐文章于 2023-11-05 14:30:07 发布
最新推荐文章于 2023-11-05 14:30:07 发布
阅读量7.6k 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongshi6/article/details/45172849
版权

#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define PROJECT_SET_SIZE 20  
#define PROJECT_ID_POS 0
#define GRAMMER_ID_POS 1
#define GRAMMER_START_CHAR_POS 5
#define BFCHAR_POS 2
#define AFCHAR_POS 3
#define PROJECT_LEN_POS 4
#define ID 10000
char st[20][30]; 
int r;

struct grammer
{
 char **g;
 char vt[127];
 char vn[27];
 char s;
 int line;
};

typedef struct
{
 int id;
 char ch;
}SElemType;


struct gprjt
{
 char **gp;
 char s;
 int line;
};

typedef struct prjset
{
 int id;
 struct prjset *next;
 char prjt[PROJECT_SET_SIZE+1];
 char pointafter[PROJECT_SET_SIZE+1];
 struct prjset *actorgo[PROJECT_SET_SIZE];
 char pointbefore;
}prjset,*pprjset;

struct head
{
 prjset *I;
 prjset *tail;
 int size;
};


char DOT = '~';
grammer g;
gprjt project;
head root;
void Input();
int OpenFile(char *s);
void CreateProjectSet();
void Closure(prjset *prjset);
int go(int rk, prjset *prjset);
void PrintPojectSet();
int IsInSet(char *s, char ch);
void JoinSet(char *s, char ch);
void main()
{
 for(;;){   
    r=1;
    cout<<"请输入文法规则(以#作为结尾)："<<endl;
    for(;;){
      string z;
   cin>>z;
   int m=0;
   int w=0;
   for(;m
    if(z[m]=='#'){w=1;break; }
     st[r][m]=z[m];
   }
   st[r][m]='@'; 
   r=r+1;
   if(w==1) break;
    }
    st[0][0]=st[1][0];st[0][1]='-';st[0][2]='>';st[0][3]=st[1][0];st[0][4]='@';
 int count;
 int i;
 int j;
 count = r;
 g.line=count;
 g.g=(char **)malloc(sizeof(char *)*g.line);
 for(i=0; i
 {
     g.g[i]=(char *)malloc(21);
  g.g[i][0] = i;
  g.g[i][1] = 0;
 }
 for(int x=0;x
 {  
  j = 2;
  for(int y=0;st[x][y]!='@';y++)
  {  
   if(st[x][y]=='-' && st[x][y+1]=='>'){y=y+1;continue;}
      else
      {
    char ch=st[x][y];
    g.g[x][j] = ch;
    g.g[x][1]++;
    j++;  
      }  
  }
 }
 g.vn[0] = g.vt[0] = 0;
 for(i=0; i
 {
  for(j=2; j<=g.g[i][1]+1; j++)
  {
   if(g.g[i][j]>='A' && g.g[i][j]<='Z')
    JoinSet(g.vn, g.g[i][j]);
   else
    JoinSet(g.vt, g.g[i][j]);
  }
 }
 g.s = g.vn[1];
 count = 0;
 for(i=0; i
  count += g.g[i][1];
 if((project.gp=(char **)malloc(sizeof(char *)*count)) == NULL)exit(1);
 int k;
 int pointpos;
 int m;
 int n;
 k = 0;
 for(i=0; i
 {
  pointpos = GRAMMER_START_CHAR_POS + 1;
  for(j=0; j
  {
   if((project.gp[k]=(char *)malloc(6+g.g[i][1])) == NULL)exit(1);   
   project.gp[k][PROJECT_ID_POS] = k;
   project.gp[k][GRAMMER_ID_POS] = i;
   project.gp[k][PROJECT_LEN_POS] = g.g[i][1]+1;
   project.gp[k][GRAMMER_START_CHAR_POS] = g.g[i][2];
   n = 3;
   for(m=GRAMMER_START_CHAR_POS+1; m
   {
    project.gp[k][m] = g.g[i][n];
    n++;
   }
   project.gp[k][pointpos] = DOT;
  
   for(m=pointpos+1; m<=project.gp[k][PROJECT_LEN_POS]+PROJECT_LEN_POS; m++)
   {
    project.gp[k][m] = g.g[i][n];
    n++;
   }
   if(pointpos==project.gp[k][PROJECT_LEN_POS]+PROJECT_LEN_POS)
   {
    project.gp[k][AFCHAR_POS] = '\0';
   }
   else
   {
    project.gp[k][AFCHAR_POS] = project.gp[k][pointpos+1];
   }
   if(pointpos==GRAMMER_START_CHAR_POS+1)
   {
    project.gp[k][BFCHAR_POS] = '\0';
   }
   else
   {
    project.gp[k][BFCHAR_POS] = project.gp[k][pointpos-1];
   }
   pointpos++;
   k++;
  }
 }
 project.s = g.s;
 project.line = k;
 cout<<"输出拓广文法："<<"\n";
 for(i=0; i
 {
  cout<<'('<<i+1<<')';
  for(j=2; j<=g.g[i][1]+1; j++)
  {
   if(j == 3)
    cout<<"->";
   cout<<g.g[i][j];
  }
  cout<<"\n";
 }
 cout<<"输出项目集："<<"\n";
 cout<<"--------------------------------------\n";
 for(i=0; i
 {
  cout<<'('<<i+1<<')';
  for(j=GRAMMER_START_CHAR_POS; j<=project.gp[i][PROJECT_LEN_POS]+PROJECT_LEN_POS; j++)
  {
   if(j==GRAMMER_START_CHAR_POS+1)
    cout<<"->";
   if(project.gp[i][j] == DOT)
    cout<<"·";
   else
    cout<<project.gp[i][j];
  }
  cout<<"\n";
 }
 cout<<"--------------------------------------\n";
 cout<<"\n";
    CreateProjectSet();
   PrintPojectSet();

 for(;;)
 {
 pprjset p;
 p=root.I;
 cout<<"输入字符串，判断其是否为当前文法的活前缀：";
 string u;cin>>u;
 int v[100]={0};
 int s=1;
 int k=0;
    for(int e=0;e
              int t=0;
     for(i=1;i<=p->pointafter[0]; i++)
       {
     if(p->pointafter[i]==u[e]) {  v[s]=p->actorgo[i-1]->id-ID;   s++;  p=p->actorgo[i-1];  t=1; break;}
       }
     if(t==0) { k=1;break;}
       }
    if(k==0) {cout<<"该字符串为该文法的活前缀"<<"\n";
              cout<<"其路径为：";
      for(int j=0;j
      {cout<<"I"<<v[j];
          if(j!=s-1) cout<<"->";
         }
     cout<<"\n";
    }
   else cout<<"该字符串不是该文法的活前缀"<<"\n";
   cout<<"继续输入字符串？（输入N停止输入，输入其他字符继续）";
   char q;cin>>q;
   if(q=='N') break;
 }
 }
}

void CreateProjectSet()
{
 int i;
 int j;
 int k;
 int id = ID;
 pprjset p,q;
 root.I = root.tail = NULL;
 if((p = (pprjset)malloc(sizeof(prjset))) == NULL) exit(1);
 p->id = id;
 p->next = NULL;
 p->prjt[0] = 0;
 p->pointafter[0] = 0;
 p->pointbefore = '\0';
 for(j=0; j
  p->actorgo[j] = NULL;
 for(j=0; j
  p->actorgo[j] = NULL;
 root.I = p;
 root.tail = p;
 root.size = 1;
 for(i=0; i
 {
  if(project.s == project.gp[i][GRAMMER_START_CHAR_POS] && DOT == project.gp[i][GRAMMER_START_CHAR_POS+1])
  {
   JoinSet(root.I->prjt, project.gp[i][PROJECT_ID_POS]);
   JoinSet(root.I->pointafter, project.gp[i][AFCHAR_POS]);
   break;
  }
 }
 Closure(root.I);
 int pos;
 for(q=root.I; q!=NULL; q=q->next)
 {
  for(i=1; i<=q->pointafter[0]; i++)
  {
   pos = i;
   pos--;
   if((p = (pprjset)malloc(sizeof(prjset))) == NULL) exit(1);  
   p->next = NULL;
   p->prjt[0] = 0;
   p->pointafter[0] = 0;
   p->pointbefore = q->pointafter[i];
   for(j=0; j
    p->actorgo[j] = NULL;
   for(j=1; j<=q->prjt[0]; j++)
   {
    if(project.gp[q->prjt[j]][AFCHAR_POS] == p->pointbefore)
     go(q->prjt[j], p);
   }
   Closure(p);
   pprjset ptr;
   int flag;
   int flagsame;
   flagsame = 1;
   flag = 1;
   for(ptr=root.I; ptr!=NULL; ptr=ptr->next)
   {
    flag = 1;
    if(p->prjt[0] == ptr->prjt[0])
    {
     for(k=1; k<=p->prjt[0]; k++)
     {
      if(!IsInSet(ptr->prjt, p->prjt[k]))
      {
       flag = 0;
       break;
      }//if      
     }//for
     
    }//if
    else
    {
     flag = 0;     
    }//else
    if(flag == 0)
     flagsame = 0;
    else
    {
     flagsame = 1;
     break;
    }
   }//for
   if(flagsame)//flagsame == 1 , 有与*p相同的项目集，删除*p
   {
    q->actorgo[i-1] = ptr;
    free(p);
   }
   else//将p挂到root.tail
   {
    q->actorgo[i-1] = p;
    p->id = ++id;
    root.tail->next = p;
    root.tail = p;
    root.size++;
   }

  }//for
 }//for
}//CreateProjectSet


void Closure(prjset *pset)
{//rk 为项目的编号，prjset指向项目集
 int i;
 int j;
 int rk;
 
 for(i=1; i<=pset->prjt[0]; i++)
 {
  rk = pset->prjt[i];
  if(IsInSet(g.vn, project.gp[rk][AFCHAR_POS]))//若圆点后字符为vn
  {
   for(j=0; j
   {
    if(project.gp[j][GRAMMER_START_CHAR_POS] == project.gp[rk][AFCHAR_POS] && project.gp[j][GRAMMER_START_CHAR_POS+1] == DOT)
    {
     JoinSet(pset->prjt, project.gp[j][PROJECT_ID_POS]);
     JoinSet(pset->pointafter, project.gp[j][AFCHAR_POS]);
    }//if
   }//for
  }//if
 }//for 
}//Closure

 

int go(int rk, pprjset prjset)
{//rk为项目编号，将rk的去向加入prjset指向的项目集中,返回项目编号，若无，返回-1
 int i;
 int j;
 int rksize;
 char rkS;
 char rkpointafter;
 if((rkpointafter = project.gp[rk][AFCHAR_POS]) == '\0')
 {
  return -1; 
 }
 int pointpos;
 pointpos = IsInSet(&project.gp[rk][PROJECT_LEN_POS], DOT);
 pointpos += PROJECT_LEN_POS;
 rksize = project.gp[rk][PROJECT_LEN_POS];
 rkS = project.gp[rk][GRAMMER_START_CHAR_POS];
 
 for(i=0; i
 {
  if(project.gp[i][GRAMMER_START_CHAR_POS] == rkS && project.gp[i][PROJECT_LEN_POS] == rksize && project.gp[i][BFCHAR_POS] == rkpointafter)
  {
   int flag;
   flag = 1;
   for(j=pointpos+2; j<=project.gp[i][PROJECT_LEN_POS]+PROJECT_LEN_POS; j++)
   {
    if(project.gp[i][j] != project.gp[rk][j])
    {
     flag = 0;
     break;
    }
   }//for
   if(flag)
   {
    JoinSet(prjset->prjt, project.gp[i][PROJECT_ID_POS]);//将项目加入项目集
    if(project.gp[i][AFCHAR_POS] != '\0')
    {JoinSet(prjset->pointafter, project.gp[i][AFCHAR_POS]);}//将项目圆点后的字符加入
    return project.gp[i][PROJECT_ID_POS];
   }//if
   else
    return -1;
  }//if
 }//for
}//go


void PrintPojectSet()
{
 pprjset p;
 int rk;
 int i;
 int j;
 cout<<"输出识别活前缀的DFA\n";
 for(p=root.I; p!=NULL; p=p->next)
 {
  cout<<"---------------------\n";
  cout<<'I'<<p->id-ID<<"\n";
  for(j=1; j<=p->prjt[0]; j++)
  {
   rk = p->prjt[j];
   for(i=GRAMMER_START_CHAR_POS; i<=project.gp[rk][PROJECT_LEN_POS]+PROJECT_LEN_POS; i++)
   {
    if(i==GRAMMER_START_CHAR_POS+1)
     cout<<"->";
    if(project.gp[rk][i] == DOT)
     cout<<"·";
    else
     cout<<project.gp[rk][i];
   }//for
   cout<<"\n";
  }//for
  cout<<"\n";
  for(i=1; i<=p->pointafter[0]; i++)
  {
   cout<<"出度:"<<p->pointafter[i]<<"指向->"<<"I"<<p->actorgo[i-1]->id-ID<<"\n";
  }//for
 }//for
 cout<<"---------------------\n";
}//PrintPojectSet

 

int IsInSet(char *s, char ch)
{
 int i;
 for(i=1; i<=s[0]; i++)
 {
  if(s[i] == ch) return i;
 }
 return 0;
}

void JoinSet(char *s, char ch)
{
 int i;
 if(!IsInSet(s,ch))
 {
  s[0]++;
  i = s[0];
  s[i] = ch;
 }
}

吹成狗的攻城狮
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
构造识别所有活前缀的dfa_工作表批量增加前缀/后缀 隔壁老王还是自家老王一目了然...
weixin_39774556的博客
12-03 296
前景提要()上节我们通过VBA成功的将创建工作表和工作表重命名这两个动作同时结合在一起，一次性完成了，大大的提高了我们的工作效率，解放了生产力，既然说到了工作表的重命名，很多小伙伴们就有话题了，有小伙伴们说他们实际操作中，没有这么规则的命名的情况，因为很多时候他们都是数据的接收者，接受来自各个环节和部门的报表，然后进行加工汇总分析的，他们希望能够在已经有的工作表的基础，对工作表的名字进行适当的修改...
构造识别所有活前缀的dfa_刷leetcode——实现 Trie (前缀树)
weixin_39764212的博客
12-13 366
这道题主要是构造前缀树节点的数据结构，帮助解答问题。原题实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。示例:Trie trie = new Trie();trie.insert("apple");trie.search("apple"); // 返回 truetrie.search("app"); // 返回 falsetr...
构造识别规范句型活前缀DFA的程序设计
01-25
武汉理工大学的编译原理课设，很难的那一个，里面很详细
构造识别规范句型活前缀DFA的程序设计源代码
01-25
武汉理工大学编译原理构造识别规范句型活前缀DFA的程序设计的详细源代码，绝对可以运行，非常完美
前缀和的应用，从一道网易笔试题说起
yeluoxiang的专栏
08-13 624
作者：帅地来源：苦逼的码农8月3号参加了网易提前批的笔试，笔试时间 120 分钟，然后有 10 道选择题（20分）， 4 道编程题（80分）， 2 道主观题（20分）。可...
DFA.rar_活前缀dfa_活前缀的DFA
09-24
在我们的场景中，活前缀DFA是用来识别输入字符串是否是文法中某个产生式的活前缀。 构建活前缀DFA的过程通常涉及以下步骤： 1. **解析输入的上下文无关文法**：首先，我们需要将给定的压缩文件中的上下文无关文法...
利用CLOSURE与GO构造识别该文法规范句型活前缀的DFA
05-09
然后，我们需要根据该文法构造出一个DFA，用于识别该文法规范句型的活前缀。 构造DFA的过程如下： 1. 定义状态集合 $Q$，其中每个状态代表一个文法符号的集合，即 $Q=\{V|V\subseteq\Sigma\cup N\}$。 2. 定义...
考虑文法G[S]: S→(S)|a (1)构造识别文法规范句型活前缀的DFA。 (2)判断该文法是否LR(O)文法，若是，构造LR(O) 分析表；若不是，请说明理由。
06-01
1. 构造DFA 先列出文法的所有项目集族： $I_0$: S' -> .S S -> .(S) S -> .a $I_1$: S' -> S. $I_2$: S -> (S). 对于$I_0$，可以通过读入符号"("或"a"进行移进操作，得到$I_1$和$I_0$。对于$I_0$，可以进行规约...
两种构造识别活前缀的DFA方法
qq_55168827的博客
04-24 7874
1.基本概念 （1）前文回顾 在上一篇文章中（https://blog.csdn.net/qq_55168827/article/details/124329569）我们简单的介绍了我们该如何的去构造活前缀的DFA，但是只讲了概念，很多同学都还是一头雾水，在这篇文章中我将会详细的介绍如何的去构造活前缀的DFA。 （2）项目->NFA->DFA 大家可能看这个图有点懵，不知道是怎么来的，其实这个图是将项目转化为左边的NFA，再根据第二章NFA和DFA转化的知识转化为了左边的DFA.
编译原理 识别c语言dfa,编译原理实验 NFA子集法构造DFA,DFA的识别 c++11实现
weixin_29612723的博客
05-19 410
#include using namespacestd;using P = pair;using ll = long long;const int maxn = 1e3 + 10;const int prime = 31;const ll mod = 1e9 + 7;int getHash(const set &s){ll res= 0;for(auto x : s)res= res * ...
编译原理 活前缀 程序
06-18
编译原理 求字符串活前缀的程序 基于C++
构造识别所有活前缀的dfa_ES的正则、通配、前缀查询的适用场景、原理和局限...
weixin_39527078的博客
11-28 492
在读到 ES官方文档-WildcardQuery、ES官方文档-RegExpQuery 、ES官方文档-PrefixQuery 的时候，觉得挺有意思，三类具有包含关系的查询竟然出了3套接口，RegExp（正则表达式）包含 Wildcard（通配符）包含Prefix（前缀）。查了一下原理，果不其然都是通过将Pattern构造成DFA来加速字符串匹配速度的。（其实TermRangeQuery（字符串范...
编译原理学习笔记（二十七）~习题：构造基于LR(0)、LR(1)项目的识别活前缀的DFA（2）
海到无边天作岸 山登绝顶我为峰
06-07 6345
题目 文法： S–>Aa | bAc | Bc | bBa A–>d B–>d 通过构造基于LR(0)、LR(1)项目的识别活前缀的DFA，判断上面文法 是否是SLR(1)文法？？ 是否是LALR(1)文法？？ 是否是LR(1)文法？？ 依次说明理由。 解 （1）基于LR(0)项目识别活前缀的DFA、 暂无，参考上一篇博文。 （2）基于LR(1)项目识别活前缀的DFA 判断： 是LR(1) 的，因为该DFA是确定的，没有冲突！ I5、 I9合并后，读入a或c时，不知道按照哪一个产生
活前缀和其他几种概念
最新发布
m0_74102824的博客
11-05 1171
E->E+E|E*E|-E|(E)|id，对于id+id*id，其中一个最右推导为E->E+E->E+E*E->E+E*id->E+id*id->id+id*id。E+id*id归约成E+E*id时，最左边的id是句柄，把E+E*id归约成E+E*E时，id是句柄。把E+E*E归约成E+E时E*E是句柄。比如E+E*E归约成E+E，句柄是E*E，那么它的活前缀就是E、E+、E+E、E+E*、E+E*E。又比如id+id*id归约成E+id*id，句柄是最左边的id，那么它的活前缀是id，因为不能超过句柄。
活前缀及构造活前缀的DFA
qq_55168827的博客
04-23 1万+
1.引入背景 上一讲我们讲了LR分析法和LR分析器的性质，我们知道了在规范规约过程中，栈内的符号串需要满足一定的条件，见下图： LR分析器的工作过程实际上就是逐步产生规范句型的活前缀。 如何保证栈内的符号串永远不会出现在句柄之后呢，于是我们引入了字的活前缀。 2.基本定义 （1）字的前缀 是指字的任意首部，如字ab的前缀有ε（ε是任何字的前缀），a ，ab ，abc。 （2）活前缀 可能大家看的有点懵，还是不理解什么叫做活前缀。其实通俗一点来讲，活前缀就是句柄的子集。...
编译原理（六）活前缀，LR文法初步介绍
热门推荐
HeroIsUseless的博客
04-28 2万+
什么是NFA(不确定的有穷自动机)和DFA(确定的有穷自动机)  有穷自动机 ( Finite Automata，FA )由两位神经物理学家MeCuloch和Pitts于1948年首先提出，是对一类处理系统建立的数学模型  这类系统具有一系列离散的输入输出信息和有穷数目的内部状态（状态：概括了对过去输入信息处理的状况）  系统只需要根据当前所处的状态和当前面临的输入信息就可以决定系统的后继...
识别活前缀的有限自动机构建方法
m0_53345417的博客
10-04 2142
识别活前缀的不确定有限自动机。这样的一个NFA只要我们进行确定化就可以得到一个确定的DFA关于确定化可以看我之前写的博客。掌握了上述基本知识后，我们现在可以开始进行构造识别活前缀的有限自动机。即 ab aAb aAcd aAcBe是可归前缀。在讲述构建方法之前，首先要掌握一些基础知识。识别活前缀的确定有限自动机DFA。
构造识别所有活前缀的dfa_史上全网最清晰后缀自动机学习(二)后缀自动机的线性时间构造算法...
weixin_39843677的博客
11-27 444
缘起上一篇【1】我们学习了SAM的基本概念. 通过转移函数知道了SAM的工作原理.现在来进一步做题. hihocoder #1445 : 后缀自动机二·重复旋律5 , 注意, 为保证循序渐进, 墙裂推荐先学习【1】再来看本文. 会发现本文是那么的自然.分析时间限制:10000ms单点时限:2000ms内存限制:512MB描述小Hi平时的一大兴趣爱好就是演奏钢琴。我们知道一个音乐旋律被...
C++ 敏感词过滤的算法之DFA算法
OO_SEN的博客
12-08 1787
DFA简介 DFA全称为：Deterministic Finite Automaton,即确定有穷自动机。其特征为：有一个有限状态集合和一些从一个状态通向另一个状态的边，每条边上标记有一个符号，其中一个状态是初态，某些状态是终态。但不同于不确定的有限自动机，DFA中不会有从同一状态出发的两条边标志有相同的符号。 在这幅图中大写字母（S、U、V、Q）都是状态，小写字母a、b为动作。通过上图我们可以看到如下关系 a b b S -----> U S -----> V U -----> V 一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值