湖南大学-计算理论实验

目录

实验A---- ADFA的可判定性 (2)

1、问题描述 (2)

2、算法设计思路 (3)

3、实验总结 (3)

4、AC代码 (3)

实验B----CFG是P成员 (4)

1、问题描述 (4)

2、算法设计思路 (5)

3、实验总结 (5)

4、AC代码 (5)

实验C----NFA转换为DFA (8)

1、问题描述 (8)

2、算法设计思路 (9)

3、实验总结 (9)

4、AC代码 (9)

实验D----两个数的互素判定 (12)

1、问题描述 (12)

2、算法设计思路 (13)

3、实验总结 (13)

4、AC代码 (13)

实验E----可判定的DFA的空问题 (14)

1、问题描述 (14)

2、算法设计思路 (15)

3、实验总结 (15)

4、AC代码 (15)

实验A---- ADFA的可判定性1、问题描述

2、算法设计思路

A:首先将输入的状态转移矩阵保存在S数组中，其中其中S[i][j]表示第i行第j列，意义为状态i经过字母j到达状态S[i][j]。

B:对每一个输入的串W,从after（after表示每次转换后的状态，初始为起始状态）开始，按照每一个字符，得到相应的后继状态，保存在after中。

C:最后判断accept[after]的值，即串在DFA上运行之后最终状态是否可接受。

3、实验总结

总的来说这一题比较容易（有点太水了），只要把输入串的每一个字符按照前面的状态得到后继状态，并不断的走下去，直到串的最后一个字符，就可以得到最后的状态，再根据其是否处在接受态，给出相应的输出

4、AC代码

#include

#include

using namespace std;

long n,m,t,a;

long s[1000][1000]; //存储转移矩阵

long accept[1000]; //存储接受状态

int main(){

while(cin>>n>>m>>t>>a){

memset(s,0,sizeof(s));

memset(accept,0,sizeof(accept));

for(int i = 1;i<=n;i++){

for(int j = 1;j<=m;j++)

cin>>s[i][j];

}

for(int i = 0;i

long temp;

cin>>temp;

accept[temp] = 1;

}

while(a--){

string temps;

cin>>temps;

int after = 1;

for(int i = 0;i

after = s[after][temps[i]-'a'+1];

}

if(accept[after]==1)

cout<<"YES"<

else

cout<<"NO"<

}}

return 0;

}

实验B----CFG是P成员1、问题描述

2、算法设计思路

A: 找出所有A->b型规则

B: 找出所有A->BC型规则

C: 考察每一个长为1的子串

D: 考察L长度的子串

E: 检查起始变元是否在table[0][n]中

3、实验总结

（1）刚开始用栈和转移矩阵来进行状态的切换，想要先把CFG转换为一个PDA，在根据PDA接受串的情况来判断（因为题目要求线性时间复杂度），后来发现转换成PDA的时候，每一个转移矩阵里应该是一个状态的集合。

（2）原本定义一个set S来表示转移矩阵，但是觉得这样还不如直接用原来的CFG按照某种规则来进行替换，让他的复杂度为线性的。具体线性替换的顺序在2中详细介绍了

4、AC代码

#include

#include

#include

using namespace std;

int main()

{

int n,m; //n行满足乔姆斯基范式的文法描述, m行待测字符串

while(cin>>n)

{

string *cfg; //CFG文法描述

cfg=new string[n];

for(int i=0;i

cin>>cfg[i]; //输入CFG文法

cin>>m; //输入待测字符串数量

string *str; //待测字符串

str=new string[m];

for(int i=0;i

cin>>str[i]; //输入待测字符串int *lstr; //待测字符串的长度lstr=new int[m];

for(int i=0;i

lstr[i]=str[i].length();

string ***table; //定义表格

table=new string**[m];

for(int i=0;i

table[i]=new string*[lstr[i]];

for(int i=0;i

for(int j=0;j

table[i][j]=new string[lstr[i]];

//找出所有A->b型规则

string Ab[100];

int num=0;

for(int i=0;i

{

for(int k=3;k

{

if(cfg[i][k]>96 && cfg[i][k]<123)

{

Ab[num]+=cfg[i][0];

Ab[num]+=cfg[i][k];

num++;

}

}

}

//找出所有A->BC型规则

string ABC[100];

int num2=0;

for(int i=0;i

{

for(int k=3;k

{

if(cfg[i][k]<91)

{

ABC[num2]+=cfg[i][0];

ABC[num2]+=cfg[i][k];

ABC[num2]+=cfg[i][k+1];

k++;

num2++;

}

}

//考察每一个长为1的子串

for(int i=0;i

{

for(int j=0;j

{

for(int k=0;k

{

if(str[i][j]==Ab[k][1]) //考察CFG文法的每一个字符

table[i][j][j]=Ab[k][0];

}

}

}

//考察l长度的子串

for(int i=0;i

{

for(int l=2;l<=lstr[i];l++) //l是子串的长度

{

for(int p=0;p

{

int j=p+l-1; //j是子串的结束位置

for(int k=p;kk

{

for(int q=0;q

{

if(table[i][p][k].find(ABC[q][1],0)!=string::npos && table[i][k+1][j].find(ABC[q][2],0)!=string::npos)

{

table[i][p][j]+=ABC[q][0];

}

}

}

}

}

}

//检查起始变元是否在table[0][n]中

for(int i=0;i

{

int flag=0;

if(table[i][0][lstr[i]-1].find(cfg[0][0],0)!=string::npos)

flag=1;

if(flag==1)

cout<<"yes"<

}

else

{

cout<<"no"<

}

} delete []cfg;

delete []str;

for(int i=0;i

for(int j=0;j

delete []table[i][j];

for(int i=0;i

delete []table[i];

delete []table;

}

return 0;

}

实验C----NFA转换为DFA

1、问题描述

Problem description

有限状态自动机（FSM "finite state machine" 或者FSA "finite state automaton" ）是为研究有限内存的计算过程和某些语言类而抽象出的一种计算模型。有限状态自动机拥有有限数量的状态，每个状态可以迁移到零个或多个状态，输入字串决定执行哪个状态的迁移。有限状态自动机可以表示为一个有向图。有限状态自动机是自动机理论的研究对象。

Input

2、 算法设计思路

状态集合的子集合，采用二进制（特征）串的方式，一个子集中包含该状态，对应的特征串就为1，否则为0，比如上面状态集合的子集{q0q1q2}，其特征串就是0111，而子集{q0}，其特征串就是0001。将对应的特征串转换为十进制的数字，得到转移函数δ。

3、 实验总结

在转化的过程中经NFA 中状态矩阵中的每一个状态的集合映射到DFA 中的一个状态。即NFA 中的状态子集为一个DFA 中的状态；只要NFA 状态子集中有一个为接受态，相应的映射的DFA 中的状态就为接受态

4、 AC 代码

#include #include #include #include

#include

#define M 99999

using namespace std;

int ans[M];

int one[M];

int zero[M];

int lft[M];

int rgt[M];

int change[M];

bool vis[M];

bool ac[M];

int cnt, n, q, f;

int index(int p)

{

int x = 1;

if(p == 1)

return 0;

int i = 0;

while(++i)

{

x <<= 1;

if(p == x)

return i;

}

return 0;

}

int mege(int a, int b)

{

while(b)

{

int x = b&(-b);

if(!(a&x))

a ^= x;

b ^= x;

}

return a;

}

void dfs(int p)

{

ans[cnt] = p;

int lsum = 0, rsum = 0;

while(p)

{

int x = p&(-p);

int y = index(x);

lsum = mege(lsum, zero[y]);

rsum = mege(rsum, one[y]);

p ^= x;

}

lft[cnt] = lsum;

rgt[cnt] = rsum;

cnt++;

if(!vis[lsum])

vis[lsum] = 1, dfs(lsum);

if(!vis[rsum])

vis[rsum] = 1, dfs(rsum);

}

int main()

{

int t;

scanf("%d", &t);

while(t--)

{

scanf("%d%d%d", &n, &q, &f);

for(int i = 0; i < n; i++)

scanf("%d", &zero[i]);

for(int i = 0; i < n; i++)

scanf("%d", &one[i]);

cnt = 0;

memset(vis, 0, sizeof(vis));

memset(ac, 0, sizeof(ac));

vis[q] = 1;

dfs(q);

int sum = 0;

for(int i = 0; i < cnt; i++)

if(ans[i]&f)

ac[i] = 1, sum++;

for(int i = 0; i < cnt; i++)

change[ans[i]] = i;

printf("%d %d %d\n", cnt, sum, 0);

for(int i = 0, j = 0; i < cnt; i++)

{

if(ac[i])

{

if(j)

printf(" ");

printf("%d", i);

j++;

}

}

printf("\n");

for(int i = 0; i < cnt; i++) {

if(i)

printf(" ");

printf("%d", change[lft[i]]);

}

printf("\n");

for(int i = 0; i < cnt; i++){

if(i)

printf(" ");

printf("%d", change[rgt[i]]);

}

printf("\n");

}

return 0;

}

实验D----两个数的互素判定

1、问题描述

2、算法设计思路

A：我们先来比较总结一下GUN中整形的范围：

int -2147483648 ~ +2147483647 (4 Bytes)

unsigned int 0 ~ 4294967295 (4 Bytes)

long == int

long long -9223372036854775808 ~ +9223372036854775807 (8 Bytes)

double 1.7 * 10^308 (8 Bytes)

unsigned int 0～4294967295

__int64的最大值：9223372036854775807

__int64的最小值：-9223372036854775808

unsigned __int64的最大值：18446744073709551615

B：从上面的结果可以看到，unsigned __int64可以符合题目的数据要求

C:用辗转相除的方法来计算最大公约数，这里使用辗转相除的递归法3、实验总结

（这题也好水）实验时要注意题目所给数据的取值范围；对于辗转相除求最大公约数，可以用非递归的或者递归的形式，两者的复杂度相差无几，鉴于递归形式的思路比较明确，而且方便编写（几行代码就可以搞定），所以使用递归形式的辗转相除。

4、AC代码

#include

#include

#include

using namespace std;

unsigned __int64 gcd(unsigned __int64 a, unsigned __int64 b)

{

if (b > 0)

{

return gcd(b, a % b);

}

return a;

}

int main(){

unsigned __int64 a,b;

while(cin>>a>>b){

if(gcd(a,b)==1){

printf("YES\n");

}

else

printf("NO\n");

}

return 0;

}

实验E----可判定的DFA的空问题

1、问题描述

2、算法设计思路

A：是否接受w的问题。ADFA是可判定的。ANFA是可判定的。ARES是可判定的。EDFA是可判定的。EQDFA是可判定的。P100。核心思想：图灵机跟踪DFA的状态和当前位置，状态和位置的变化由转移函数决定。

B：DFA不接受任意串存在以下几种情况：没有接受状态、接受状态独立、接受状态和起始状态不在同一个团中；基于以上三种情况编写代码

3、实验总结

不要去根据DFA可能接受某一个串去判断一个DFA大的可判定性，而是从相反的方向来考虑问题：即判断DFA是否拒绝所有的串。DFA拒绝所有的串只可能存在以上三种情况。

4、AC代码

#include

#include

#include

#include

using namespace std;

bool vis[110];

bool ac[110];

int num[110][110];

int n, m, f, p, cnt;

bool dfs(int k)

{

vis[k] = 1;

if(ac[k])

{

return 1;

}

for(int i = 0; i < m; i++)

if(!vis[num[k][i]] && dfs(num[k][i]))

{

return 1;

}

return 0;

}

int main()

{

while(scanf("%d%d", &n, &m)!=EOF)

{

memset(vis, 0, sizeof(vis));

memset(ac, 0, sizeof(ac));

for(int i = 0; i < n; i++)

for(int j = 0; j < m; j++)

scanf("%d", &num[i][j]);

scanf("%d", &f);

for(int i = 0; i < f; i++)

{

scanf("%d", &p), ac[p] = 1;

}

if(f)

if(dfs(0))

printf("NO\n");

else

printf("YES\n");

else

printf("YES\n");

}

return 0;

}