湖南大学离散数学程序设计题.docx
《湖南大学离散数学程序设计题.docx》由会员分享，可在线阅读，更多相关《湖南大学离散数学程序设计题.docx（61页珍藏版）》请在冰豆网上搜索。
湖南大学离散数学程序设计题
程序设计题2010年
语言不限，显示方式中的表格线可以不出现，但要显示为表格的样子，到底做哪道题，在上机时由老师宣布或抽签决定。
1、自动生成真值表
2、判断两个公式是否等值
3、生成主析取、主合取范式
4、判断一个公式是否合法
已给出了基本方法，判断过程中也给出判断过程。
5、集合运算
6、关系矩阵与关系的复合
说明二个序偶之间用分号（;）分隔。
“关系一的矩阵”是指给出关系一的关系矩阵。
直接利用序偶进行复合，得到其关系的复合
7、求关系的自反与对称闭包
关系的自反闭包
关系的对称闭包
8、利用矩阵求其关系的复合与传递闭包
9、判断运算是否可结合
10、判断运算一对运算二是否可分分配
11、判断两个代数是否同构
//1.1自动生成真值表
#include
#include
usingnamespacestd;
classGongshi{//得到任意公式真值表的类
private:
stringyuanshimingti;//用来保存输入的原始公式。
stringguodu;//过渡用的字符串。
stringzuijian;//保存命题变元的字符串。
intnum;//原子命题个数
public:
Gongshi（stringa）//构造函数
{
yuanshimingti=a;
guodu="00000000000000000000";//初始化为0000....为了更好的储存数据
zuijian="00000000000000000000";
huoquzimu（）;//调用设置函数
}
voidhuoquzimu（）//得到原子命题的函数
{
intk=0;
for（inti=0;yuanshimingti[i]!
=0;i++）
if（（yuanshimingti[i]>='a'）&&（yuanshimingti[i]<='z'））{//原子命题必须是小写字母
guodu[k]=yuanshimingti[i];
k++;
}
guodu[k]='\0';//字符串结束符
setguodu（）;//调用函数，去掉重复的
}
voidsetguodu（）//化简所得到的命题变元，去掉重复的。
{
intk=1;
zuijian[0]=guodu[0];
for（inti=1;guodu[i]!
=0;i++）{
if（jianyan（guodu[i],i））{
zuijian[k]=guodu[i];
k++;
}
}
guodu[k]='\0';
num=k;//记下命题变元的个数
}
booljianyan（chara,intn）//检验是否重复的子函数
{
for（inti=0;iif（a==zuijian[i]）
return0;
}
return1;
}
voidoperator1（）//主操作函数1
{
for（inti=0;icout<cout<inta=1;//用来储存一共有多少种解释。
for（i=0;ia=a*2;
//分2^num种情况，来解释真值表
intb=0,c[10]={0,0,0,0,0,0,0,0,0,0};
for（i=0;iintd=b;
for（intj=0;j//将十进制转化为二进制
c[j]=d%2;
d=（int）d/2;
}
for（j=num-1;j>-1;j--）{
cout<}
b++;
stringcc="0000000000";
for（j=0;jif（c[j]==1）
cc[j]='1';
else
cc[j]='0';
}
stringaa;
aa=yuanshimingti;
//通过双重循环，用0/1来替代命题变员
for（intk=0;kfor（intj=0;aa[j]!
=0;j++）{//原始公式
if（aa[j]==zuijian[k]）
aa[j]=cc[num-k-1];
}
}
cout<cout<<"\n";
}
}
charoperator2（stringchushi）//操作函数2，得到某种解释下真值表的值，主要思路：
从前到后，从外到里！
{
//第一步，先找到和计算出最外面的括号！
inta,b=0,k=0;
for（inti=0;chushi[i-1]!
='）'&&chushi[i]!
=0;i++）{
if（chushi[i]=='）'）
b=i;
}
for（i=0;chushi[i]!
='）'&&chushi[i]!
=0;i++）{
if（chushi[i]=='（'）
a=i;
}
if（b!
=0）{
for（i=a+1;iguodu[k]=chushi[i];
k++;
}
guodu[k]='\0';
chart;
t=operator2（guodu）;
chushi[a]=t;
intz=a+1;
for（k=b+1;chushi[k-1]!
=0;k++）{
chushi[z]=chushi[k];
z++;
}
returnoperator2（chushi）;
}
//第二步再去掉否定
for（i=0;chushi[i]!
=0;i++）{
if（chushi[i]=='!
'）{
if（chushi[i+1]=='1'）
chushi[i+1]='0';
else
chushi[i+1]='1';
intz=i;
for（k=z+1;chushi[k-1]!
=0;k++）{
chushi[z]=chushi[k];
z++;
}
}
}
//第三步直接计算真值
charc='1';
for（i=0;chushi[i]!
=0;i++）{
if（chushi[i]=='+'）{
if（（chushi[i-1]=='1'）||（chushi[i+1]=='1'））
chushi[i+1]='1';
else
chushi[i+1]='0';
}
if（chushi[i]=='^'）{
if（（chushi[i-1]=='1'）&&（chushi[i+1]=='1'））
chushi[i+1]='1';
else
chushi[i+1]='0';
}
if（chushi[i+1]!
=0）
c=chushi[i+1];
}
returnc;
}
};
intmain（）
{
stringa1;//用来接收输入的字符串
cout<<"（合取用^代替，析取用+代替，命题变元用小写字母）"<cout<<"请输入表达式：
";
cin>>a1;
cout<Gongshigongshi1（a1）;//初始化一个类的对象.
gongshi1.operator1（）;//调用该类的主操作函数，实现目的.
return0;
}
//1.2判断两个公式是否等值
#include
#include
usingnamespacestd;
classGongshi{//得到任意公式真值表的类
private:
stringyuanshimingti;//用来保存输入的原始公式1。
stringyuanshimingti2;//用来保存输入的原始公式2。
stringguodu;//过渡用的字符串。
stringzuijian;//保存命题变元的字符串。
stringguodu2;//过渡用的字符串2。
stringzuijian2;//保存命题变元的字符串2。
intnum;//公式1原子命题个数
intnum2;//公式2原子命题个数
public:
Gongshi（stringa,stringb）//构造函数
{
yuanshimingti=a;
yuanshimingti2=b;
guodu="00000000000000000000";//初始化为0000....为了更好的储存数据
zuijian="00000000000000000000";
guodu2="00000000000000000000";
zuijian2="00000000000000000000";
huoquzimu1（）;//调用设置函数设置公式一
huoquzimu2（）;//调用设置函数设置公式二
}
//公式一
voidhuoquzimu1（）//得到原子命题的函数
{
intk=0;
for（inti=0;yuanshimingti[i]!
=0;i++）
if（（yuanshimingti[i]>='a'）&&（yuanshimingti[i]<='z'））{//原子命题必须是小写字母
guodu[k]=yuanshimingti[i];
k++;
}
guodu[k]='\0';//字符串结束符
setguodu（）;//调用函数，去掉重复的
}
voidsetguodu（）//化简所得到的命题变元，去掉重复的。
{
intk=1;
zuijian[0]=guodu[0];
for（inti=1;guodu[i]!
=0;i++）{
if（jianyan（guodu[i],i））{
zuijian[k]=guodu[i];
k++;
}
}
guodu[k]='\0';
num=k;//记下命题变元的个数
}
//公式二
voidhuoquzimu2（）//得到原子命题的函数
{
intk=0;
for（inti=0;yuanshimingti2[i]!
=0;i++）
if（（yuanshimingti2[i]>='a'）&&（yuanshimingti2[i]<='z'））{//原子命题必须是小写字母
guodu2[k]=yuanshimingti2[i];
k++;
}
guodu2[k]='\0';//字符串结束符
setguodu2（）;//调用函数，去掉重复的
}
voidsetguodu2（）//化简所得到的命题变元，去掉重复的。
{
intk=1;
zuijian2[0]=guodu2[0];
for（inti=1;guodu2[i]!
=0;i++）{
if（jianyan（guodu2[i],i））{
zuijian2[k]=guodu2[i];
k++;
}
}
guodu2[k]='\0';
num2=k;//记下命题变元的个数
}
booljianyan（chara,intn）//检验是否重复的子函数
{
for（inti=0;iif（a==zuijian[i]）
return0;
}
return1;
}
voidoperator1（）//主操作函数1
{
booljz=1;
for（inti=0;icout<cout<"<inta=1;//用来储存一共有多少种解释。
for（i=0;ia=a*2;
//分2^num种情况，来解释真值表
intb=0,c[10]={0,0,0,0,0,0,0,0,0,0};
for（i=0;iintd=b;
for（intj=0;j//将十进制转化为二进制
c[j]=d%2;
d=（int）d/2;
}
for（j=num-1;j>-1;j--）{
cout<}
b++;
//公式一
stringcc="0000000000";
for（j=0;jif（c[j]==1）
cc[j]='1';
else
cc[j]='0';
}
stringaa;
aa=yuanshimingti;
//通过双重循环，用0/1来替代命题变员
for（intk=0;kfor（intj=0;aa[j]!
=0;j++）{//原始公式
if（aa[j]==zuijian[k]）
aa[j]=cc[num-k-1];
}
}
cout<//公式二
cc="0000000000";//重新初始化
for（j=0;jif（c[j]==1）
cc[j]='1';
else
cc[j]='0';
}
stringaa2;
aa2=yuanshimingti2;
//通过双重循环，用0/1来替代命题变员
for（k=0;kfor（intj=0;aa2[j]!
=0;j++）{//原始公式
if（aa2[j]==zuijian[k]）
aa2[j]=cc[num-k-1];
}
}
cout<<""<cout<<""<<（operator2（aa2）==operator2（aa））;
if（operator2（aa2）!
=operator2（aa））
jz=0;
cout<<"\n";
}
if（jz）
cout<<"二个公式等值相等"<else
cout<<"二个公式不等值不相等"<}
charoperator2（stringchushi）//操作函数2，得到某种解释下真值表的值，主要思路：
从前到后，从外到里！
{
//第一步，先找到和计算出最外面的括号！
inta,b=0,k=0;
for（inti=0;chushi[i-1]!
='）'&&chushi[i]!
=0;i++）{
if（chushi[i]=='）'）
b=i;
}
for（i=0;chushi[i]!
='）'&&chushi[i]!
=0;i++）{
if（chushi[i]=='（'）
a=i;
}
if（b!
=0）{
for（i=a+1;iguodu[k]=chushi[i];
k++;
}
guodu[k]='\0';
chart;
t=operator2（guodu）;
chushi[a]=t;
intz=a+1;
for（k=b+1;chushi[k-1]!
=0;k++）{
chushi[z]=chushi[k];
z++;
}
returnoperator2（chushi）;
}
//第二步再去掉否定
for（i=0;chushi[i]!
=0;i++）{
if（chushi[i]=='!
'）{
if（chushi[i+1]=='1'）
chushi[i+1]='0';
else
chushi[i+1]='1';
intz=i;
for（k=z+1;chushi[k-1]!
=0;k++）{
chushi[z]=chushi[k];
z++;
}
}
}
//第三步直接计算真值
charc='1';
for（i=0;chushi[i]!
=0;i++）{
if（chushi[i]=='+'）{
if（（chushi[i-1]=='1'）||（chushi[i+1]=='1'））
chushi[i+1]='1';
else
chushi[i+1]='0';
}
if（chushi[i]=='^'）{
if（（chushi[i-1]=='1'）&&（chushi[i+1]=='1'））
chushi[i+1]='1';
else
chushi[i+1]='0';
}
if（chushi[i+1]!
=0）
c=chushi[i+1];
}
returnc;
}
};
intmain（）
{
stringa1,a2;//用来接收输入的字符串
cout<<"（合取用^代替，析取用+代替，命题变元用小写字母）"<cout<<"公式一：
";
cin>>a1;
cout<<"公式二:
";
cin>>a2;
cout<Gongshigongshi（a1,a2）;//初始化一个类的对象.
gongshi.operator1（）;//调用该类的主操作函数，实现目的.
return0;
}
//1.3自动生成主析取范式和主合取范式
#include
#include
usingnamespacestd;
classGongshi{//得到任意公式真值表的类
private:
stringyuanshimingti;//用来保存输入的原始公式。
stringguodu;//过渡用的字符串。
stringzuijian;//保存命题变元的字符串。
intnum;//原子命题个数
public:
Gongshi（stringa）//构造函数
{
yuanshimingti=a;
guodu="00000000000000000000";//初始化为0000....为了更好的储存数据
zuijian="00000000000000000000";
huoquzimu（）;//调用设置函数
}
voidhuoquzimu（）//得到原子命题的函数
{
intk=0;
for（inti=0;yuanshimingti[i]!
=0;i++）
if（（yuanshimingti[i]>='a'）&&（yuanshimingti[i]<='z'））{//原子命题必须是小写字母
guodu[k]=yuanshimingti[i];
k++;
}
guodu[k]='\0';//字符串结束符
setguodu（）;//调用函数，去掉重复的
}
voidsetguodu（）//化简所得到的命题变元，去掉重复的。
{
intk=1;
zuijian[0]=guodu[0];
for（inti=1;guodu[i]!
=0;i++）{
if（jianyan（guodu[i],i））{
zuijian[k]=guodu[i];
k++;
}
}
guodu[k]='\0';
num=k;//记下命题变元的个数
}
booljianyan（chara,intn）//检验是否重复的子函数
{
for（inti=0;iif（a==zuijian[i]）
return0;
}
return1;
}
voidoperator1（）//主操作函数1
{
intz=0,y=0;
inttrue1[30],qq1=0;
intfalse1[30],qq2=0;
for（inti=0;icout<cout<inta=1;//用来储存一共有多少种解释。
for（i=0;ia=a*2;
//分2^num种情况，来解释真值表
intb=0,c[10]={0,0,0,0,0,0,0,0,0,0};
for（i=0;iintd=b;
for（intj=0;j//将十进制转化为二进制
c[j]=d%2;
d=（int）d/2;
}
for（j=num-1;j>-1;j--）{
cout<}
b++;
stringcc="0000000000";
for（j=0;jif（c[j]==1）
cc[j]='1';
else
cc
升级会员 