湖大离散数学实验代码汇总
整理一下大一上过的离散数学的实验代码...
实验一
#include
#define INF 0x3f3f3f3f
using namespace std;
void rule1(char a[],int i)
{
if(a[i]>='a' && a[i]<='z') a[i]='1';
else if(a[i]=='0') a[i]='1';
}
int rule2(char a[],int i)
{
int n=strlen(a);
int _result=0;
if(i+1 实验二
#include
#define INF 0x3f3f3f3f
using namespace std;
int getalpha(char a[],char b[])
{
int n=strlen(a),i=0,j=0,k=0;
for(i=0;i='a'&&a[i]<='z')||(a[i]>='A'&&a[i]<='Z'))
{
if(strchr(b,a[i])==NULL)
{
b[j]=a[i];
j++;
}//改进1：用strchr函数来代替搜索过程
}
sort(b,b+j);//改进2：用sort函数将字母排序
b[j]='\0';
return j;
}
void fillvalue(char a[],char varchar[],int nvar,char valchar[],char resultchar[])
{
int nLen=strlen(a),i=0,j=0,k=0;
for(i=0;i='a'&&cc<='z')||(cc>='A'&&cc<='Z')||cc=='='||cc=='-'||
cc=='+'||cc=='*'||cc=='!'||cc=='0'||cc=='1'||cc=='('||cc==')')
a[cnt++]=cc;
}
int main()
{
while(1)//改进点4：持续化输入
{
char pstate[120]={' '},pstate0[120]={' '},charlist[120]={' '},charval[120]={' '};
char minitem[1024][52]={' '},maxitem[1024][52]={' '},truetable[1024]={' '};
int i=0,nold=0,nnew=0,nvar=1,nrow=1,j=0,flagsum=1,iminitem=0,imaxitem=0;
printf("请输入公式(析+,合*,条-,双=,否定!,01):\n");
//gets(pstate0);
getformula(pstate0);
fflush(stdin);
nold=strlen(pstate0)+1;
nnew=strlen(pstate0);
for(i=0;i=0;--j)
// {
// if(charval[j]=='1')
// if(flagsum==1)
// {
// charval[j]='0';
// flagsum=1;
// }
// else
// break;
// else if(charval[j]=='0')
// if(flagsum==1)
// {
// charval[j]='1';
// flagsum=0;
// break;
// }
// else
// break;
// }
int tmp=sum;
for(int j=nvar-1;j>=0;--j)
{
charval[j]=(tmp%2+'0');
tmp/=2;
}
sum++;
//改进7：优化为变元赋值的逻辑
}
printf("\n");
printf("主析取范式：\n");
for(i=0;i 实验三
#include //修改点1：万能头文件
using namespace std;
struct tmd{
char gs[120],gslast[120],reason[120];
int nletter,nused,isletter,iscond;
};
void nonoop2(char aa[])
{
int i=0,j=0;
while(i??????
gs0[i].gs[k-j-1+1]='\0';
nonoop2(gs0[i].gs);
setreason(gs0,i,r1,i-1,-1,0,1,0);
break;
}
else if(pstate[j]=='=')
{
gs0[i].nletter=strlen(pstate);
for(k=0;k=nlen)
{
gs0[i].nletter=strlen(pstate);
for(k=0;kgs0[j].nletter)
k=j;
if(k>i) swap(gs0[i],gs0[k]);//修改点6：用swap替代中间元
}
return nlen;
}
int main()
{
while(1)//改进点7:连续输入
{
tmd gs0[100];
char result0[128];
tmd tmrec[1024];
char stmp[128];
char lastreason[128]="";
string r01="假言推理";
int i=0,j=0,k=0;
int np=1,np0=0,is0k=0;
int i0=0,nposletter=0,nposcond=0;
np0=inputprimary(gs0);
printf("输入要推理的结论，结论只能是文字，\n若是条件式、析取式请先手工转换为条件，将前件作为附加前提：\n");
gets(result0);
fflush(stdin);
for(i=0;i=np)
break;
i0=i;
nposletter=i;
strcpy(stmp,tmrec[i].gs);
np0=np-1;
while(np>np0)
{
np0=np;
for(i=0;i 实验四
#include
#include
#include
#include
#include
#include
struct tmd
{
char gs[120], gsLast[120], niyou[120];//前件与后件及理由
int nLitter, nUsed, isLitter, isCond;
};
void nonoop2( char aa[] )
{
//!!p=p
int i = 0, j = 0;
while (i < strlen( aa ) - 2)
{
//至少还有两个字符
if (((i + 1) < strlen( aa )) && (aa[i] == '!') && (aa[i + 1] == '!'))
{
j = i;
while (j < strlen( aa ) - 2)
{
aa[j] = aa[j + 2];
j++;
}
aa[j] = '\0';
break;
}
else
i++;
}
}
void printYsh( struct tmd tmdrec[], int np )
{
int i = 0;
for (i = 0; i < np; i++)
{
if (tmdrec[i].isLitter == 1)
printf( "(%d)\t%s为真\t\t\t%s---文字\n", i + 1, tmdrec[i].gs, tmdrec[i].niyou );
else if (tmdrec[i].isCond == 1)
printf( "(%d)\t%s+%s为真\t\t\t%s---析取式\n", i + 1, tmdrec[i].gs, tmdrec[i].gsLast, tmdrec[i].niyou );
else
printf( "(%d)\t%s为真\t\t\t%s\n", i + 1, tmdrec[i].gs, tmdrec[i].niyou );
}
}
//修改1：调换函数位置，否则会出现调用未定义函数的情况
int setNiyou( struct tmd tmdrec[], int np, char ny0[], int j0, int j1, int nUsed0, int isCond0, int isLitter0 )
{
//将字符串ny0与j0赋到推理意见中
char stmdpj0[20], stmdpj1[20];
int nLen1 = 0, j = 0, nLenj0 = 0, nLenj1 = 0;
nLen1 = strlen( ny0 );
itoa( j0 + 1, stmdpj0, 10 );
nLenj0 = strlen( stmdpj0 );//前一个依据
itoa( j1 + 1, stmdpj1, 10 );
nLenj1 = strlen( stmdpj1 );//后一个依据
if (j0 == -1)
{
//原始前提
for (j = 0; j < nLen1; j++)
tmdrec[np].niyou[j] = ny0[j];
tmdrec[np].niyou[j] = '\0';
}
else if (j1 == -1)//由前一步推理所得结论
{
tmdrec[np].niyou[0] = '(';
for (j = 0; j < nLenj0; j++)
tmdrec[np].niyou[j + 1] = stmdpj0[j];
tmdrec[np].niyou[j + 1] = ')';
for (j = 0; j < nLen1; j++)
tmdrec[np].niyou[j + 2 + nLenj0] = ny0[j];
tmdrec[np].niyou[j + 2 + nLenj0] = '\0';
}
else
{
//由前二步推理所得
tmdrec[np].niyou[0] = '(';
for (j = 0; j < nLenj0; j++)
tmdrec[np].niyou[j + 1] = stmdpj0[j];
tmdrec[np].niyou[j + 1] = ')';
tmdrec[np].niyou[nLenj0 + 2] = '(';
for (j = 0; j < nLenj1; j++)
tmdrec[np].niyou[nLenj0 + 3 + j] = stmdpj1[j];
tmdrec[np].niyou[nLenj0 + 3 + j] = ')';
for (j = 0; j < nLen1; j++)
tmdrec[np].niyou[nLenj0 + nLenj1 + 4 + j] = ny0[j];
tmdrec[np].niyou[nLenj0 + nLenj1 + 4 + j] = '\0';
}
tmdrec[np].nUsed = nUsed0;//附加前提从未使用过nUsed0,int isCond0,int isLitter0
tmdrec[np].isCond = isCond0;//是条件式
tmdrec[np].isLitter = isLitter0;//是文字
}
void swaptmd(tmd &a,tmd &b)
{
tmd temp;
temp=a;
a=b;
b=temp;
}
int inputPrimary( struct tmd gs0[] )
{
struct tmd tmdp;
char pstate[120];
char *ny0 = "前提条件";
char *ny1 = "条件式转为析取式";
char *ny2 = "双条件导出的析取式";
int i = 0, j = 0, nLen = 0, k = 0;
int i0 = 0;//原始条件
printf( "输完一个前提条件请按回车，不输直接回车则结束\n析+,合*,条-,双=,否定!\n前提中只能为双条件、单条件、析取式,\n若为2个条件的合取,请输入2个前提,文字请在最前面输入:\n" );
while (1)
{
gets( pstate );
nLen = strlen( pstate );
if (nLen == 0)
{
break;
}//设置nUsed,isLitter,isCond,nLittle的值
//判断是否为文字
if (nLen == 1)//标注单个文字
{
gs0[i].nLitter = strlen( pstate );
gs0[i].gs[0] = pstate[0];
gs0[i].gs[1] = '\0';
gs0[i].gsLast[0] = '\0';
setNiyou( gs0, i, ny0, -1, -1, 0, 0, 1 );//前提类型，无，无，未使用，不是条件式，是文字
}
else if ((nLen == 2) && (pstate[0] == '!')) //标注！p
{
gs0[i].nLitter = strlen( pstate );
gs0[i].gs[0] = pstate[0];
gs0[i].gs[1] = pstate[1];
gs0[i].gs[2] = '\0';
gs0[i].gsLast[0] = '\0';
setNiyou( gs0, i, ny0, -1, -1, 0, 0, 1 );//前提类型，无，无，未使用，不是条件式，是文字
}
else
{
for (j = 0; j < nLen; j++)
{
if (pstate[j] == '-')//标注条件式p-q
{
gs0[i].nLitter = strlen( pstate );
for (k = 0; k < nLen; k++)
gs0[i].gs[k] = pstate[k];//整个表达式进入gs
gs0[i].gs[k] = '\0';
gs0[i].gsLast[0] = '\0';
setNiyou( gs0, i, ny0, -1, -1, 0, 0, 0 );//前提类型，无，无，未使用，不是析取式，不是文字
i++;
gs0[i].nLitter = gs0[i - 1].nLitter;
gs0[i].gs[0] = '!';
for (k = 0; k < j; k++)
gs0[i].gs[k + 1] = pstate[k];
gs0[i].gs[k + 1] = '\0';
nonoop2( gs0[i].gs );
for (k = j + 1; k < nLen; k++)
gs0[i].gsLast[k - j - 1] = pstate[k];
gs0[i].gsLast[k - j - 1] = '\0';
setNiyou( gs0, i, ny1, i - 1, -1, 0, 1, 0 );//前提类型，无，无，未使用，是条件式，不是文字
break;
}
else if (pstate[j] == '=')//标注双条件p=q
{
//先保存双条件
gs0[i].nLitter = strlen( pstate );
for (k = 0; k < strlen( pstate ); k++) { gs0[i].gs[k] = pstate[k]; }//双条件全部进gs
gs0[i].gs[k] = '\0';
gs0[i].gsLast[0] = '\0';
setNiyou( gs0, i, ny0, -1, -1, 0, 0, 0 );//前提类型，无，无，未使用，是条件式，不是文字
//p-q即!p+q
i++;
gs0[i].nLitter = strlen( pstate );
gs0[i].gs[0] = '!';
for (k = 0; k < j; k++) { gs0[i].gs[k + 1] = pstate[k]; }//p进gs
gs0[i].gs[k + 1] = '\0';
for (k = j + 1; k < nLen; k++) { gs0[i].gsLast[k - j - 1] = pstate[k]; }//q进gsLast
gs0[i].gsLast[k - j - 1] = '\0';
setNiyou( gs0, i, ny2, i - 1, -1, 0, 1, 0 );//前提类型，无，无，未使用，是条件式，不是文字
nonoop2( gs0[i].gs );//去掉可能存在的!!?
//q-p=p+!q
i++;
gs0[i].nLitter = gs0[i - 1].nLitter;
for (k = 0; k < j; k++) { gs0[i].gs[k] = pstate[k]; }//条件前件p进gs
gs0[i].gs[k] = '\0';
gs0[i].gsLast[0] = '!';
for (k = j + 1; k < nLen; k++) { gs0[i].gsLast[k - j - 1 + 1] = pstate[k]; }//条件后件!q进gsLast
gs0[i].gsLast[k - j - 1 + 1] = '\0';
setNiyou( gs0, i, ny2, i - 2, -1, 0, 1, 0 );//前提类型，无，无，未使用，是条件式，不是文字
nonoop2( gs0[i].gsLast );//去掉可能存在的!!?
break;
}
else if (pstate[j] == '+')//标注析取式p+q，也要分解到gs与gsLast中
{
gs0[i].nLitter = strlen( pstate );
for (k = 0; k < j; k++)
gs0[i].gs[k] = pstate[k]; //前件进gs
gs0[i].gs[k] = '\0';
for (k = j + 1; k < nLen; k++)
gs0[i].gsLast[k - j - 1] = pstate[k]; //条件全部进gs
gs0[i].gsLast[k - j - 1] = '\0';
setNiyou( gs0, i, ny0, -1, -1, 0, 1, 0 );//前提类型,无，无，未使用，是条件式，不是文字
break;
}
}
if (j >= nLen)//不是条件式，也不是文字，则是普通的条件
{
gs0[i].nLitter = strlen( pstate );
for (k = 0; k < nLen; k++)
gs0[i].gs[k] = pstate[k]; //公式全进gs
gs0[i].gs[k] = '\0';
gs0[i].gsLast[0] = '\0'; //gsLast为空串
setNiyou( gs0, i, ny0, -1, -1, 0, 0, 0 );//前提类型，无，无，未使用，不是条件式，不是文字
}
}
i++;//当前公式处理完以后，指针i的值增1
}
nLen = i;//按字符串的长度排序
for (i = 0; i < nLen - 1; i++)
{
k = i;
//for (j = i + 1; j < nLen - 1; j++)
for (j = i + 1; j < nLen; j++)//修改2：修改循环条件使得最后的元素可排序
if (gs0[k].nLitter > gs0[j].nLitter)
k = j;
if (k > i)
{
swaptmd(gs0[i],gs0[k]);//修改3：使用自定义的swaptmd排序
// tmdp = gs0[i];
// gs0[i] = gs0[k];
// gs0[k] = tmdp;
}
}
return nLen;
}
int main()
{
struct tmd gs0[100];//推理前提条件
char result0[128]; //结论
struct tmd tmdrec[1024];//最多1000步
char stmdp[128];
char lastNiYou[128] = " ";//上一个推理式的理由
char *ny01 = "消解";
int i = 0, j = 0, k = 0;
int np = 1, np0 = 0, isOk = 0;
int i0 = 0, nPosLitter = 0, nPosCond = 0;//文字起始的位置，首个文字的位置，消解式的位置
np0 = inputPrimary( gs0 );
//输入结论
printf( "输入要推理的结论，结论只能是文字，\n若是条件式，析取式请先手工转换为条件，将前件作为附加前提：" );
gets( result0 );
fflush( stdin );
for (i = 0; i < np0; i++)
{
tmdrec[i] = gs0[i];//所有原始公式转抄到tmdrec中
}
np = i;//推理队列的尾部指针
nPosLitter = 0;//文字的位置号
nPosCond = 0;//条件的位置号
isOk = 0;
i0 = -1;
while (1)
{
i = i0 + 1;//寻找下一个文字，i是起始位置，np是命令串的长度
while ((i < np) && (tmdrec[i].isLitter != 1))
i++;
if (i >= np)
break;//找不到文字我就没法推理了
i0 = i;//记录从源头查询的首个文字的位置号，下次从此号往后寻找
nPosLitter = i;//记录文字的位置
strcpy( stmdp, tmdrec[i].gs );//保存当前文字的内容
np0 = np - 1;
while (np > np0) //从当前文字的下一个位置起寻找析取式，则一路往下走
{
np0 = np;
for (i = 0; i < np; i++)//找到一个没有用过的戏曲式
if ((tmdrec[i].isCond == 1) && (tmdrec[i].nUsed == 0))
break;
if (i == np)
break;//没有找到则结束推理，所有条件式都用到了
while (i < np)//若找到了这样的条件式
{
if ((tmdrec[i].isCond == 1))//若是条件式
{
//与上条命令的来源不同，或者但是同为前提条件也是可以的，即首个字符不是（
if (((strcmp( lastNiYou, tmdrec[i].niyou ) != 0) || ((strcmp( lastNiYou, tmdrec[i].niyou ) == 0) && tmdrec[i].niyou[0] != '(')))
{
if ((tmdrec[i].gs[0] == '!') && (stmdp[0] != '!') && (strlen( tmdrec[i].gs ) - strlen( stmdp ) == 1)) ////////// !p+q p cuo
{
//如果析取式的前件与stmdp即可消解，则将后件保存的stmdp中
j = 0;
while (j < strlen( stmdp ))//依次比较每个字符
{
if (tmdrec[i].gs[j + 1] != stmdp[j])
break;//有一个不相等则结束比较
j++;
}
if (j >= strlen( stmdp )) //如果比到最后仍然相等，则这二个可消解
{
strcpy( lastNiYou, tmdrec[i].niyou );
tmdrec[nPosLitter].nUsed++; //这个文字用过一次了
tmdrec[i].nUsed++; //这个析取式用过一次了
strcpy( stmdp, tmdrec[i].gsLast ); //将次消解结果保存到推导序列中
strcpy( tmdrec[np].gs, stmdp ); //将当前推出来的结果保存起来
tmdrec[np].gsLast[0] = '\0'; //后件清空，保存当前条件
setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 ); //前提类型，有，无，未使用，不是条件
nPosLitter = np; //记录当前文字的序号
np++;
if (strcmp( result0, stmdp ) == 0)
{
isOk = 1; //推出结论同条原是调节的下一轮
break;
}
}
}
else if ((tmdrec[i].gsLast[0] == '!') && (stmdp[0] != '!') && (strlen( tmdrec[i].gsLast ) - strlen( stmdp ) == 1)) //a+!b b dui
{
//如果析取式的后件与stmdp即可消解，则将前件保存到stmdp中
j = 0;
while (j < strlen( stmdp )) //依次比较每一个字符
{
if (tmdrec[i].gsLast[j + 1] != stmdp[j])
break; //有一个不相等则结束比较
j++;
}
if (j >= strlen( stmdp )) //如果比到最后仍然相等，则这两个可消解
{
strcpy( lastNiYou, tmdrec[i].niyou );
tmdrec[nPosLitter].nUsed++; //这个文字用过一次了
tmdrec[i].nUsed++; //这个析取式用过一次了
strcpy( stmdp, tmdrec[i].gs ); //将次消解结果保存到推导序列中
strcpy( tmdrec[np].gs, stmdp ); //将当前推出来的结果保存起来
tmdrec[np].gsLast[0] = '\0'; //后件清空，保存当前条件
setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 ); //前提类型，有，无，未使用，不是条件
nPosLitter = np; //记录当前文字的序号
np++;
if (strcmp( result0, stmdp ) == 0)
{
isOk = 1; //推出结论同条原是调节的下一轮
break;
}
}
}
else if ((tmdrec[i].gs[0] != '!') && (stmdp[0] == '!') && (strlen( tmdrec[i].gs ) - strlen( stmdp ) == -1)) // p+q !p
{
//如果析取式的后件与stmdp即可消解，则将前件保存到stmdp中
j = 0;
while (j < strlen( tmdrec[i].gs )) //依次比较每一个字符
{
if (stmdp[j + 1] != tmdrec[i].gs[j])
break; //有一个不相等则结束比较
j++;
}
if (j >= strlen( tmdrec[i].gs ))
{
strcpy( lastNiYou, tmdrec[i].niyou );
tmdrec[nPosLitter].nUsed++; //这个文字用过一次了
tmdrec[i].nUsed++; //这个析取式用过一次了
strcpy( stmdp, tmdrec[i].gsLast ); //将次消解结果保存到推导序列中
strcpy( tmdrec[np].gs, stmdp ); //将当前推出来的结果保存起来
tmdrec[np].gsLast[0] = '\0'; //后件清空，保存当前条件
setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 ); //前提类型，有，无，未使用，不是条件
nPosLitter = np; //记录当前文字的序号
np++;
if (strcmp( result0, stmdp ) == 0)
{
isOk = 1; //推出结论同条原是调节的下一轮
break;
}
}
}
else if ((tmdrec[i].gsLast[0] != '!') && (stmdp[0] == '!') && (strlen( tmdrec[i].gsLast ) - strlen( stmdp ) == -1)) //p+q !q
{
//如果析取式的后件与stmdp即可消解，则将前件保存到stmdp中
j = 0;
while (j < strlen( tmdrec[i].gsLast ))//依次比较每一个字符
{
if (stmdp[j + 1] != tmdrec[i].gsLast[j])
break; //有一个不相等则结束比较
j++;
}
if (j >= strlen( tmdrec[i].gsLast ))//如果比到最后仍然相等，则这两个可消解
{
strcpy( lastNiYou, tmdrec[i].niyou );
tmdrec[nPosLitter].nUsed++; //这个文字用过一次了
tmdrec[i].nUsed++; //这个条件用过一次了
strcpy( stmdp, tmdrec[i].gs ); //将此中间结果保存到推导序列中
strcpy( tmdrec[np].gs, stmdp ); //将当前推出来的结果保存起来
tmdrec[np].gsLast[0] = '\0'; //后件清空，保存当前条件
setNiyou( tmdrec, np, ny01, nPosLitter, i, 0, 0, 1 );//前提类型，有，无，未使用，不是条件式
nPosLitter = np; //记录当前文字的序号
np++;
if (strcmp( result0, stmdp ) == 0)
{
isOk = 1; //推出结论同原始条件的下一轮
break;
}
}
}
}
}
i++;//判断下一个表达式是否为条件，是否为可推理的条件式
}
}
if (isOk == 1)
break; //我推出来了，不要再找下一个文字了
}
if (isOk == 1)
printf( "我推出来了,推理过程如下:\n" );
else
printf( "我推不出来,推理过程如下:\n" );
printYsh( tmdrec, np );
}
实验五
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include 实验六
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include 实验七
//共 6 个修改点
//修改点1：万能头文件
//修改点2：合并if和for语句，使代码简洁易懂
//修改点3：用strchr函数来代替搜索过程
//修改点4：使用memset函数替代双重循环初始化数组
//修改点5：利用布尔函数优化交互
//修改点6：利用while判断输入是否合法
#include //修改点1：万能头文件
#define N 100
//集合的基本运算交、并、差、对称差、直积
int printYsh(char a[])
{
//由于集合保存在一个字符串，显示时在各元素之间加入逗号，及返回长度
int nLen = 0;
int i = 0;
nLen = strlen(a);
if (nLen > 0)
{
printf("%c", a[0]);
}
for (i = 1; i < nLen; i++)
{
printf(",%c", a[i]);
}
printf("\n");
return nLen;
}
int printRelaYsh(char a[][3], int n)
{
//由于集合保存在一个字符串，显示时在各元素之间加入逗号，及返回长度
int i = 0;
// if (n > 0)
// {
// printf("<%c,%c>", a[0][0], a[0][1]);
// }
// for (i = 1; i < n; i++)
// {
// printf(",<%c,%c>", a[i][0], a[i][1]);
// }
for (i = 1; i <= n; i++)
{
printf(",<%c,%c>", a[i-1][0], a[i-1][1]);
}
//修改点2：合并if和for语句，使代码简洁易懂
printf("\n");
return n;
}
int printRelaMatrix(int M[][N], int n)
{
//打印关系矩阵的值
int i = 0, j = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%4d", M[i][j]);
printf("\n");
}
}
int inputYsh(char a[])
{
//由于集合保存在一个字符串，但是输入时各字符是用逗号分隔的
//形参a是一个数组，送入是一个地址值，在函数对该数组的修改会反映在主函数
char nLen = 0, i = 0, j = 0, k = 0;
char stmp[1024];//最多1024个字符
printf("集合元素只能是A-Za-z0-9,其他字符被当作分隔符而去掉：\n");
gets(stmp);
fflush(stdin);
nLen = strlen(stmp);
for (i = 0; i < nLen; i++)
{
if (((stmp[i] >= 'A') && (stmp[i] <= 'Z')) ||
((stmp[i] >= 'a') && (stmp[i] <= 'z')) || ((stmp[i] >= '0') && (stmp[i] <= '9')))
//还要判断该字符 是否已经在a中出现过
if(strchr(a,stmp[i])==NULL)
{
a[j]=stmp[i];
j++;
}
//修改点3：用strchr函数来代替搜索过程
}
a[j] = '\0';
return j;//字符串的长度
}
int inputRelaYsh(char a[][3])
{
//由于序偶是保存在一个字符串，但是输入时各字符是用逗号分隔的
char nLen = 0, i = 0, j = 0;
int nbit = 0;
char stmp[1024];//最多1024个字符
printf("序偶只能是A-Za-z0-9。其他字符被当作分隔符而去掉，形如:\n");
gets(stmp);
fflush(stdin);
nLen = strlen(stmp);
for (i = 0; i < nLen; i++)
{
if (((stmp[i] >= 'A') && (stmp[i] <= 'Z')) ||
((stmp[i] >= 'a') && (stmp[i] <= 'z')) ||
((stmp[i] >= '0') && (stmp[i] <= '9')))
{
a[j][nbit] = stmp[i];
nbit++;
if (nbit == 2)
{
a[j][2] = '\0';
j++;
nbit = 0;
}
}
}
return j;//字符串的长度
}
int relaCompose(char R[][3], char S[][3], char T[][3], int nR, int nS)
{
//关系的复合，让RS中每个序偶进行比较，组合成功的写入到T中
int i = 0, j = 0, k = 0, m = 0;
char a1 = ' ', a2 = ' ';
for (i = 0; i < nR; i++)
{
for (j = 0; j < nS; j++)
{
if (R[i][1] == S[j][0]) // of R, of S then in T
{
a1 = R[i][0];//还要在T中寻找新序偶是否存在
a2 = S[j][1];
m = 0;
for (m = 0; m < k; m++)
{
//如果已经存在则中止
if ((T[m][0] == a1) && (T[m][1] == a2))
{
break;
}
}
if (m >= k) //如果原来不存在则加入其中
{
T[k][0] = a1;
T[k][1] = a2;
T[k][2] = '\0';
k++;
}
}
}
}
return k;
}
int relaSelf(char a[], char R[][3], int nR, char T[][3])
{
//自反闭包：判断集合a中各序偶是否在关系R中出现，若没出现则加入其中
int i = 0, j = 0, k = 0;
int nLen = 0;
nLen = strlen(a);
//先将关系R全部转抄到T中
for (i = 0; i < nR; i++)
{
T[i][0] = R[i][0];
T[i][1] = R[i][1];
}
for (i = 0; i < nLen; i++)
{
for (j = 0; j < nR; j++)
{
if ((R[j][0] == a[i]) && (R[j][1] == a[i])) // in R
{
break;
}
}
if (j >= nR) //不在关系R中
{
T[j][0] = a[i];
T[j][1] = a[i];
T[j][2] = '\0';
nR++;
}
}
return nR;
}
int relaSym(char R[][3], char T[][3], int nR)
{
//自反闭包:判断集合a中各序偶是否在关系R中出现，若没出现加入其中
int i = 0, j = 0, k = 0;
int nLen = nR;
//先将关系R全部转抄到T中
for (i = 0; i < nR; i++)
{
T[i][0] = R[i][0];
T[i][0] = R[i][0];
}
for (i = 0; i < nR; i++)
{
for (j = 0; j < nR; j++)
{
//每个序偶到本关系中寻找对偶关系，若找到了则是对称，否则加上
if ((R[j][0] == R[i][1]) && (R[j][1] == R[i][0])) //, inR
{
break;
}
}
if (j >= nR) //不是成对出现
{
T[nLen][0] = R[i][1];
T[nLen][1] = R[i][0];
T[nLen][2] = '\0';
nLen++;
}
}
return nLen;
}
void rela2matrix(char a[], char R[][3], int nR, int M[][N])
{
//关系矩阵的行数与列数，等于基本元素即数组a中当前元素的个数
int i = 0, j = 0, na = 0, k = 0, m = 0;
na = strlen(a); //基本元素的个数
//关系矩阵的每个元素清0
// for (i = 0; i < na; i++)
// {
// for (j = 0; j < na; j++)
// {
// M[i][j] = 0;
// }
// }
memset(M,0,sizeof(M));
//修改点4：使用memset函数替代双重循环初始化数组
//寻找关系R中每个序偶之元素对应的序号，
//从而在数组M的指定位置置成1
for (i = 0; i < nR; i++)
{
//确定第i个序偶的首个元素在基本元素集中的序号
for (j = 0; j < na; j++)
{
if (R[i][0] == a[j])
{
k = j;
break;
}
}
//确定第i个序偶的次个元素在基本元素集中的序号
for (j = 0; j < na; j++)
{
if (R[i][1] == a[j])
{
m = j;
break;
}
}
M[k][m] = 1;
}
}
int matrix2rela(char a[], char R[][3], int M[][N])
{
int i = 0, j = 0, k = 0, nLen = 0;
nLen = strlen(a);
for (i = 0; i < nLen; i++)
{
for (j = 0; j < nLen; j++)
{
if (M[i][j] == 1)
{
//有次序偶则生成也
R[k][0] = a[i];
R[k][1] = a[j];
k++;
}
}
}
return k;
}
void matrixmulti(int M[][100], int R[][N], int T[][N], int n)
{
//两个方程相乘，超过二则为1
int i = 0, j = 0, k = 0, nsum = 0;
for (i = 0; i < n; i++)
{
for(j=0; j= 1)
{
nsum = 1;
break;
}
}
T[i][j] = nsum;
}
}
}
int trorder(char R[][3], char RM[][3], int nR, int n)
{
char T[1024][3], T2[1024][3];//关系R的i次方
int i = 0, nT = 0, j = 0, k = 0, nRM = 0, nT2 = 0;
//先将R保存到RM中
for (i = 0; i < nR; i++)
{
RM[i][0] = R[i][0];
RM[i][1] = R[i][1];
T[i][0] = R[i][0];
T[i][1] = R[i][1];
}
nRM = nR;
nT = nR;
for (i = 2; i <= n; i++)//n-1为止
{
//将R@R的复合函数暂存到T
printRelaYsh(T, nT);
printRelaYsh(R, nR);
nT2 = relaCompose(T, R, T2, nT, nR);
printRelaYsh(T2, nT2);
printf("\n");
//将复合以后的添加到R中，得到R+R@R，剔除重复的元素
for (j = 0; j < nT2; j++)
{
for (k = 0; k < nRM; k++)
{
if ((T2[j][0] == RM[k][0]) && (T2[j][1] == RM[k][1]))
{
break;
}
}
if (k >= nRM)//如果没有找到，则加入其中
{
RM[nRM][0] = T2[j][0];
RM[nRM][1] = T2[j][1];
nRM++;
}
}
//将T2复制给T
for (j = 0; j < nT2; j++)
{
T[j][0] = T2[j][0];
T[j][1] = T2[j][1];
}
nT = nT2;
}
return nRM;
}
int rPower(char R[][3], char T[][3], int nR, int n, int np)
{
//R的np次方
char T2[1024][3];//关系R的i次方
int i = 0, nT = 0, j = 0, k = 0, nRM = 0, nT2 = 0;
//先将R保存到T中
for (i = 0; i < nR; i++)
{
T[i][0] = R[i][0];
T[i][1] = R[i][1];
}
nT = nR;
for (i = 2; i <= np; i++) //n-1为止
{
//将T@R的复合暂存到T2
nT2 = relaCompose(T, R, T2, nT, nR);
//将T2复制给T
for (j = 0; j < nT2; j++)
{
T[j][0] = T2[j][0];
T[j][1] = T2[j][1];
}
nT = nT2;
}
return nT;
}
int trmatrix(int R[][N], int n)
{
int i = 0, j = 0, k = 0;
for (j = 0; j < n; j++)
{
for (i = 0; i < n; i++)
{
if (R[i][j] == 1)
{
for (k = 0; k < n; k++)
{
//将第j行加到第i行
R[i][k] = R[i][k] + R[j][k];
if (R[i][k] >= 1)
{
R[i][k] = 1;
}
}
}
}
}
return n;
}
int main()
{
char a[1024], R1[1024][3], R2[1024][3], T[1024][3];
int nLen1 = 0, nLen2 = 0, nT = 0, M[N][N], nChoice = 0;
int MR1[N][N], MR2[N][N];
int i = 0, n = 0;
bool flag=false;//修改点5：利用布尔函数优化交互
while (1)
{
printf("\n========================\n");
if(!flag)
printf("1...输入相关元素值\n");
if(flag)
{
printf("2...R1*R2关系的复合\n");
printf("3...自反闭包\n");
printf("4...对称闭包\n");
printf("5...序偶形式的关系转关系矩阵\n");
printf("6...利用矩阵求关系的复合\n");
printf("7...利用序偶形式的复合求传递闭包\n");
printf("8...利用warshall算法的求传递闭包\n");
printf("9...R2*R1关系的复合\n");
printf("10..R1的任意次方\n");
printf("11..R2的任意次方\n");
}
printf("0...退出\n");
printf("========================\n您的选择: ");
//scanf("%d", &nChoice);
//fflush(stdin);
while(scanf("%d",&nChoice))
if((nChoice>=0&&nChoice<=8)) break;
else printf("请重新输入\n");
//修改点6：利用while判断输入是否合法
if (nChoice == 0)
{
break;
}
switch (nChoice)
{
case 1:
{
flag=true;
printf("输入集合a:");
inputYsh(a);
printf("输入关系R1:");
nLen1 = inputRelaYsh(R1);
printf("输入关系R2:");
nLen2 = inputRelaYsh(R2);
printf("A:");
printYsh(a);
printf("关系R1:");
printRelaYsh(R1, nLen1);
printf("关系R2:");
printRelaYsh(R2, nLen2);
break;
}
case 2:
{
nT = relaCompose(R1, R2, T, nLen1, nLen2);
printf("R1@R2:");
printRelaYsh(T, nT);
break;
}
case 9:
{
nT = relaCompose(R2, R1, T, nLen2, nLen1);
printf("R2@R1:");
printRelaYsh(T, nT);
break;
}
case 3:
{
nT = relaSelf(a, R1, nLen1, T);
printf("R1的自反闭包：");
printRelaYsh(T, nT);
break;
}
case 4:
{
nT = relaSym(R1, T, nLen1);
printf("R1的对称闭包：");
printRelaYsh(T, nT);
break;
}
case 5:
{
//序偶形式的关系转换为矩阵形式
rela2matrix(a, R1, nLen1, M);
printf("R1关系的序偶");
printRelaYsh(R1, nLen1);
printf("R1关系的矩阵\n");
printRelaMatrix(M, strlen(a));
break;
}
case 6:
{
//利用矩阵求关系的复合
//先求出二个关系的关系矩阵
rela2matrix(a, R1, nLen1, MR1);
printf("R1关系的矩阵\n");
printRelaMatrix(MR1, strlen(a));
rela2matrix(a, R2, nLen2, MR2);
printf("R2关系的矩阵\n");
printRelaMatrix(MR2, strlen(a));
matrixmulti(MR1, MR2, M, strlen(a));
printf("复合后的矩阵\n");
printRelaMatrix(M, strlen(a));
printf("\n复合后的序偶");
nT = matrix2rela(a, T, M);
printRelaYsh(T, nT);
break;
}
case 7://trorder(char R[][3],char RM[][3],int nR,int n)
{
nT = trorder(R1, T, nLen1, strlen(a));
printf("R1的传递闭包:");
printRelaYsh(T, nT);
printf("\n序偶转化为数组\n");
rela2matrix(a, T, nT, M);
printRelaMatrix(M, strlen(a));
break;
}
case 8:
{
rela2matrix(a, R1, nLen1, M);
printf("R1关系的序偶");
printRelaYsh(R1, nLen1);
printf("R1关系中的矩阵\n");
printRelaMatrix(M, strlen(a));
trmatrix(M, strlen(a));
printf("warshall后的矩阵\n");
printRelaMatrix(M, strlen(a));
printf("\n序偶");
nT = matrix2rela(a, T, M);
printRelaYsh(T, nT);
break;
}
case 10:
{
printf("n=?");
scanf("%d", &n);
fflush(stdin);
nT = rPower(R1, T, nLen1, strlen(a), n);
printf("R1的%d次方：", n);
printRelaYsh(T, nT);
printf("\n序偶转换为数组\n");
rela2matrix(a, T, nT, M);
printRelaMatrix(M, strlen(a));
break;
}
case 11:
{
printf("n=?");
scanf("%d", &n);
fflush(stdin);
nT = rPower(R2, T, nLen2, strlen(a), n);
printf("R2的%d次方：", n);
printRelaYsh(T, nT);
printf("\n序偶转换为数组\n");
rela2matrix(a, T, nT, M);
printRelaMatrix(M, strlen(a));
break;
}
//序偶形式的关系到关系矩阵
/*
a,b,c,d,e
;;;;;
;;;;;
*/
}
}
}