求算符文法的FIRSTVT集的算法

原理

数据结构

1 G = {‘key‘:[v1,v2,v3],‘key‘:[v1,v2,v3]};
2 VN = [];
3 Vt = [];
4 FirstVT = {‘key‘:[v1,v2,v3],‘key‘:[v1,v2,v3]};

也就是map里放list,同样将文法压缩,对于产生式相同的发到一个map元素里,追加到map元素对应的list后面

算法过程

1、 先求出直接满足A->a 或 A->Ba的文法的A的FIRSTVT集合

2、 扫描FIRSTVT集,将满足蔓延性公式的终结符加到非终结符的FIRSTVT集合中。蔓延性满足下面的条件

若a属于FIRSTVT(B) 且有产生式A->B..... 则a属于FIRSTVT(A)

输入

1 8
2 S->#E#
3 E->E+T
4 E->T
5 T->T*F
6 T->F
7 F->P^F|P
8 P->(E)
9 P->i

完整算法

 1 #!/usr/bin/env python
 2 #-*-coding:utf8-*-
 3
 4 #count = raw_input(‘Please input P count:‘);
 5
 6 #print "Input all P:\n";
 7 f = open("./2.in", ‘r‘,1);
 8 count = int(f.readline());
 9 #G = [];
10 G = {};
11 VN = [];
12 Vt = [];
13 FirstVT = {};
14 for i in range(0,count):
15     #key = raw_input("P key:");
16     #value = raw_input("P value:");
17     line = f.readline().strip();
18     print line;
19     arr = line.split("->");
20     #P = {‘key‘:key,‘value‘:value};
21     #P = {
22         #‘key‘:arr[0],
23         #‘value‘:arr[1]
24     #};
25     VN.append(arr[0]);
26
27     #G.append();
28     if arr[0] not in G:
29         G[arr[0]] = [];
30     G[arr[0]].append(arr[1]);
31 #print G;
32
33 #for p in G:
34     #a  = ‘‘;
35     #if (p[‘value‘][0] not in VN):
36         #a = p[‘value‘][0];
37     #elif (len(p[‘value‘]) >= 2 ) and ( p[‘value‘][0] in VN):
38         #a = p[‘value‘][1];
39
40 for k in G:
41     vs = G.get(k);
42     for v in vs:
43         a = ‘‘;
44         if v[0] not in VN:
45             a = v[0];
46         elif len(v) >= 2 and v[0] in VN and v[1] not in VN:
47             a = v[1];
48
49         if k not in FirstVT:
50             FirstVT[k] = [];
51
52         if a != ‘‘:
53             #将形如 A->a 的 FirstVT[A] 添加进 a
54             FirstVT[k].append(a);
55
56 #print FirstVT;
57
58 stack = [];
59
60 for _k in FirstVT:
61     _vs = FirstVT.get(_k);
62     for _v in _vs:
63         # 将 形如 A->a 的入栈
64         stack.append([_k,_v]);
65
66
67 #print stack;
68
69 while len(stack) > 0:
70     ij =  stack.pop();
71     B = ij[0];
72     a = ij[1];
73     for A in G:
74         vvs = G.get(A);
75         for _vs in vvs:
76             # 存在形式如  A->B &&  f[ia,ja]为假
77             if _vs[0] == B and A != B and ( a not in FirstVT.get(A) ):
78                 FirstVT[A].append(a);
79                 stack.append([A,a]);
80
81
82
83 #print FirstVT;
84
85 print ‘------------------------------------------------‘
86 for fk in FirstVT:
87     fv = FirstVT.get(fk);
88     print ‘FIRSTVT(‘,fk,‘)={‘,;
89     for item in fv:
90         if item != fv[-1] :
91             print item,‘,‘,;
92         else:
93             print item,;
94     print ‘}\n‘,;

运行结果

时间: 2023-12-23 07:07:50

求算符文法的FIRSTVT集的算法的相关文章

技术文章 | 频繁项集挖掘算法之FPGrowth

频繁项集挖掘算法用于挖掘经常一起出现的item集合(称为频繁项集),通过挖掘出这些频繁项集,当在一个事务中出现频繁项集的其中一个item,则可以把该频繁项集的其他item作为推荐. 比如经典的购物篮分析中啤酒.尿布故事,啤酒和尿布经常在用户的购物篮中一起出现,通过挖掘出啤酒.尿布这个啤酒项集,则当一个用户买了啤酒的时候可以为他推荐尿布,这样用户购买的可能性会比较大,从而达到组合营销的目的. 常见的频繁项集挖掘算法有两类,一类是Apriori算法,另一类是FPGrowth.Apriori通过不断的

分布式系统互斥算法---非集中式算法

集中式算法存在单点失效问题,那么我们接着来看一下非集中式算法. 假设共享资源副本被复制了n次,每个副本有其自身协作者控制访问:如果某个进程要访问共享资源,主要获得m>n/2个协作者投票允许即可. 如图1所示,如果进程0要发起访问请求,只要8个协作者中有5个(包括其自身)投票允许即可. 图1 但是该算法也有自身的缺陷,即当某个协作者崩溃时,它将忘记之前投过的票,可能在回复后又投了重复的票给其他请求者:比如已经允许了p进程访问共享资源,之后该协作者重置了,又允许了q进程去访问共享资源,此时可能会出现

[ML&DL] 频繁项集Apriori算法

频繁项集Apriori算法 Reference 数据挖掘十大算法之Apriori详解 Apriori算法详解之[一.相关概念和核心步骤] 关联分析之Apriori算法 haha 算法理解部分主要是前两个链接,写的很靠谱.在实际中再配合上hadoop的mapreduce.

常见算法:C语言求最小公倍数和最大公约数三种算法

最小公倍数:数论中的一种概念,两个整数公有的倍数成为他们的公倍数,当中一个最小的公倍数是他们的最小公倍数,相同地,若干个整数公有的倍数中最小的正整数称为它们的最小公倍数,维基百科:定义点击打开链接 求最小公倍数算法: 最小公倍数=两整数的乘积÷最大公约数 求最大公约数算法: (1)辗转相除法 有两整数a和b: ① a%b得余数c ② 若c=0,则b即为两数的最大公约数 ③ 若c≠0,则a=b,b=c,再回去运行① 比如求27和15的最大公约数过程为: 27÷15 余1215÷12余312÷3余0

关于求最大子段和的几种算法

一.比较朴素的算法 算法思想:我们确定每个子段和开始的位置,分别为第一个,第二个,第三个......第N个,然后计算从这个位置开始到这个位置之后的每个位置的子段和,更新记录最大的子段和. 时间复杂度:O(n^2) 算法实现(Java): package com.Third; import java.util.*; public class Main3{ public static int maxSum2(int a[]){ int nowSum=0;//用于记录从指定位置到当前位置累加的值 in

C语言求最小公倍数和最大公约数三种算法(经典)

把以前写的一些经验总结汇个总,方便给未来的学弟学妹们做个参考! --------------------------永远爱你们的:Sakura 最小公倍数:数论中的一种概念,两个整数公有的倍数成为他们的公倍数,其中一个最小的公倍数是他们的最小公倍数,同样地,若干个整数公有的倍数中最小的正整数称为它们的最小公倍数,维基百科:定义点击打开链接 求最小公倍数算法: 最小公倍数=两整数的乘积÷最大公约数 求最大公约数算法: (1)辗转相除法 有两整数a和b: ① a%b得余数c ② 若c=0,则b即为两

算法导论-求(Fibonacci)斐波那契数列算法对比

目录 1.斐波那契数列(Fibonacci)介绍 2.朴素递归算法(Naive recursive algorithm) 3.朴素递归平方算法(Naive recursive squaring) 4 .自底向上算法(Bottom-up) 5. 递归平方算法(Recursive squaring) 6.完整代码(c++) 7.参考资料 内容 1.斐波那契数列(Fibonacci)介绍 Fibonacci数列应该也算是耳熟能详,它的递归定义如上图所示. 下面2-6分别说明求取Fibonacci数列的

Bridging signals(求最长上升自序列nlogn算法)

Bridging signals Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 2582    Accepted Submission(s): 1665 Problem Description 'Oh no, they've done it again', cries the chief designer at the Waferlan

求最大子数组的和,算法导论只分治递归求解,暴力求解,记忆扫描方法。

#include<iostream> #include<vector> using namespace std; /*******************************************************************************************/ // 分治方法,利用递归的思想 // ugly_chen 2014.11.3 22:24 //说明:把数组分为两部分,右边部分和左边部分,要不就是右边部分和左边部分之和. // ---