离散数学实验

最新推荐文章于 2023-04-15 01:59:38 发布
最新推荐文章于 2023-04-15 01:59:38 发布
阅读量3k 收藏 11
点赞数 3
分类专栏： C语言基本算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/canhelove/article/details/80646453
版权

//真值运算

#include<stdio.h>

int main()
{
int p,q;
char t='y';
while(t)
{
printf("是否运算程序(y/n):\n");
scanf("%c",&t);
if('y'==t || 'Y' == t)
{
printf("输入p,q的真值(0或1):");
scanf("%d%d",&p,&q);
getchar();
/* if((p != 1)&&(p != 0))
{
printf("请重新输入p值");
scanf("%d",&q);
getchar();
}
if((q != 1)&&(q != 0))
{
printf("请重新输入q值");
scanf("%d",&q);
getchar();
}
*/
if(!!q == 0 && !!p == 0)
{
printf("﹁p = 1\n");
printf("﹁q = 1\n");
printf("p∧q =0\n");
printf("p∨q = 0\n");
printf("p^q = 0\n");
printf("p→q = 1\n");
printf("p<->q = 1\n");
}
else if(!!p == 0 && !!q == 1)
{
printf("﹁p = 1\n");
printf("﹁q = 0\n");
printf("p∧q = 0\n");
printf("p∨q = 1\n");
printf("p^q = 1\n");
printf("p→q = 1\n");
printf("p<->q = 0\n");
}
else if(!!p == 1&&!!q == 0)
{
printf("﹁p = 0\n");
printf("﹁q = 1\n");
printf("p∧q = 0\n");
printf("p∨q = 1\n");
printf("p^q = 1\n");
printf("p→q = 0\n");
printf("p<->q = 0\n");
}
else if(!!p == 1&&!!q == 1)
{
printf("﹁p = 0\n");
printf("﹁q = 0\n");
printf("p∧q = 1\n");
printf("p∨q = 1\n");
printf("p^q = 0\n");
printf("p→q = 1\n");
printf("p<->q = 1\n");
}
continue;
}
if('n' == t || 'N' == t)
break;
}
return 0;

}

//集合的运算

#include <stdio.h>
int disc;


int  jj(int a[],int b[],int n,int m) //交集 
{
int i,j,k=0;
for (i=0;i<n;i++)
{
for (j=0;j<m;j++)
{ if (a[i]==b[j]) //如果相同就输出并计数 
{
printf("%d,",a[i]);
k++;
}
}
}

return k;
}


void xd(int a[],int b[],int n,int m) //判断集合是否相等 
{
    if (n==m&&jj(a,b,n,m)==n)
    {
        printf("相等！\n");
    }
    else
        printf("不相等！\n");
}


void  bj(int a[],int b[],int n,int m) //并集 
{
int i,j,x,k,find=0;
int p[100];
for (i=0;i<n;i++) //复制a集合 
{
p[i]=a[i];
}
for (j=0;j<m;j++)
{
for (k=0;k<n;k++)
{
if (a[k]==b[j])
find=1;
}
if (find==0) //从b集合中复制与a集合中不同的数 
{
p[i]=b[j];
i++;
}
find=0;

}
x=i;
for(i=0;i<x;i++)
{
printf("%d,",p[i]);
}
}
 int* xb(int a[],int b[],int n,int m) //相对补 
{
int i=0,j,k,find=0;
int p[100];
for (j=0;j<m;j++)
{
for (k=0;k<n;k++) //在a集合中找 与b集合相等的数 
{
if (a[k]==b[j])
find=1;
}
if (find==0) //复制a集合中与b集合不相等的数 
{
p[i]=b[j];
i++;
}
find=0;
}
disc=i; //全局变量记录个数 

return p; //返回指针p 
}


int main()
{
int a[10],b[10];
int i,j,e=0,f=0;
int x,y;
int * q;
int * p;
int aa[100];
int bb[100];


printf ("请输入的A集合的个数N:");
scanf("%d",&x);
printf("请输入B集合的个数M:");
scanf("%d",&y);
printf("集合A:\n"); 
for (i=0;i<x;i++)
{
scanf("%d",&a[i]);
}
printf("集合B:\n");
for (j=0;j<y;j++)
{
scanf("%d",&b[j]);
}
     
printf("该两集合是否相等:\n");
    xd(a,b,x,y);
    printf("\n");
printf("该两个集合的并集结果如下：\n");
bj(a,b,x,y);
printf("\n");
printf("该两个集合的交集结果如下：\n");
    jj(a,b,x,y);
    printf("\n");
    printf("该A-B集合的相对补集结果如下：\n");
q=xb(b,a,y,x);


for(i=0;i<disc;i++)
{
  aa[i]=q[i]; //aa复制 A-B 
printf("%d ",q[i]);
e++;
}
printf("\n");
    printf("该B-A集合的相对补集结果如下：\n");
    p=xb(a,b,x,y);


for(i=0;i<disc;i++)
{
  bb[i]=p[i]; //bb复制B-A 
printf("%d ",p[i]);
f++;
}
printf("\n");
printf("该两个集合的相对差集结果如下：\n"); //对称差即 两个相对补的 并集 
bj(aa,bb,e,f);

}

//矩阵的表示

#include<stdio.h>
#define LEN 100 


int num;  
int relation_num;  
int relation_L[LEN][LEN];   //关系集合,邻接矩阵 
int relation_K[LEN][LEN];   //可达矩阵 
int relation_G[LEN][LEN]; //关系矩阵 
void Prit_L(void);
void Prit_K(void);
void Prit_G(void);


int main(void)
{
while(1)
{
int tmp1, tmp2;  
        int i,j;
               
        for(i = 0; i < LEN;i++) //初始化  0 
        {
        for(j = 0; j < LEN; j++)
        {
        relation_G[i][j] = relation_L[i][j] = relation_K[i][j] = 0;
        }
        }
 //       memset(relation, 0, sizeof(relation));    
 //       memset(A, 0, sizeof(A));  
  printf("输入元素个数(0--结束)："); 
  scanf("%d",&num);
  printf("输入关系个数(0--结束)："); 
  scanf("%d",&relation_num);
 
  if(!num && !relation_num) break;
 
  printf("输入元素关系：\n"); 
 
        for(i = 1; i <= relation_num; i++)  
        {  
scanf("%d%d",&tmp1,&tmp2); //输入他们的关系，存在为1，不存在为0 
            relation_L[tmp1][tmp2] = 1;  
        }  
        
        
       
Prit_L();
    Prit_K();
Prit_G();

  
}



return 0;
}


void Prit_L(void)
{
int i,j;

printf("邻接矩阵为：\n"); 
for(i = 1; i <= num; i++)
{
for( j = 1; j <= num; j++)
{
printf("%d",relation_L[i][j]); //邻接矩阵就是输入的矩阵 
}
printf("\n");
}

}


void Prit_K(void)
{
int i,j;

    for(i = 1; i <= num; i++)   //复制 
    {  
        for( j = 1; j <= num; j++)  
        {  
            relation_K[i][j] = relation_L[i][j];  
        }  
    }  
    for(i = 1; i <= num; i++)   //warshll算法求传递闭包 
    {  
        for( j = 1; j <= num; j++)  
        {  
            if(relation_K[j][i] == 1)  
            {  
                for(int k = 1; k <= num; k++)  
                {  
                    relation_K[j][k] = relation_K[j][k] + relation_K[i][k];  
                    if(relation_K[j][k] >= 1)  
                    {  
                       relation_K[j][k] =  1;  
                    }  
                }  
            }  
        }  
    }  

printf("可达矩阵为：\n"); //可达矩阵就是它的传递闭包 
for(i = 1; i <= num; i++)
{
for( j = 1; j <= num; j++)
{
printf("%d",relation_K[i][j]);
}
printf("\n");
}

}


void Prit_G()
{
int i,j,t = 1;

printf("关联矩阵为：\n"); 
for(i = 1; i <= num; i++)
{
for( j = 1; j <= num; j++)
{
if(relation_L[i][j] > 0)
{
relation_G[i][t]++; //如果改边存在 他的前结点，后结点都与这条边有关，所以加1 
relation_G[j][t]++;
t++; //边数加1 
}
}
}

for(i = 1; i <= num; i++)
{
for( j = 1; j < t; j++)
{
printf("%d",relation_G[i][j]);
}
printf("\n");
}
}


//二元关系的判断
#include<stdio.h> 
#define LEN  100
  
int  Reflexivity();   //自反性  
int  Symmetry();      //对称性  
int  Transmission();  //传递性  
int  Irreflexivity();  //反自反性  
int  Irsymmetry();    //反对称性  
void  Warshall();       //Warshall算法  
  
int num;  
int relation_num;  
int relation[LEN][LEN];   //关系集合 
int A[LEN][LEN];   //传递闭包
  
int main()  
{  
    while(1)   //输入元素个数和他们的关系的个数 
    {  
        int tmp1, tmp2;  
        int i,j;
               
        for(i = 0; i < LEN;i++) //初始化  0 
        {
        for(j = 0; j < LEN; j++)
        {
        relation[i][j] = A[i][j] = 0;
        }
        }
 //       memset(relation, 0, sizeof(relation));    
 //       memset(A, 0, sizeof(A));  
  printf("输入元素个数(0--结束)："); 
  scanf("%d",&num);
  printf("输入关系个数(0--结束)："); 
  scanf("%d",&relation_num);
 
  if(!num && !relation_num) break;
 
  printf("输入元素关系：\n"); 
        for(i = 1; i <= relation_num; i++)  
        {  
scanf("%d%d",&tmp1,&tmp2); //输入他们的关系 
            relation[tmp1][tmp2] = 1;  
        }  
  
        if(Reflexivity())   //自反性 
        {  
            printf("具有自反性\n");
        }  
        else  
        {  
            printf("不具有自反性\n");  
        }  
    
        if(Symmetry())   //对称性 
        {  
            printf("具有对称性\n");  
        }  
        else  
        {  
            printf("不具有对称性\n");    
        }  
     
  
        if(Transmission())   //传递性 
        {  
            printf("具有传递性\n"); 
        }  
        else  
        {  
            printf("不具有传递性\n"); 
        }  
       
        if(Irreflexivity())   //反自反性 
        {  
            printf("具有反自反性\n"); 
        }  
        else  
        {  
            printf("不具有反自反性\n");  
        }  
      
  
        if(Irsymmetry())   //反对称性 
        {  
            printf("具有反对称性\n");  
        }  
        else  
        {  
            printf("不具有反对称性\n");  
        }  
        
  
    }  
    return 0;  
}  
  
int  Reflexivity()  //自反性   看 11 22 33 44 等位置上是否为1 
{  
  int i;
 
    for(i = 1; i <= num; i++)  
    {  
        if(relation[i][i] != 1)  
        {  
            return 0;  
        }  
    }  
    return 1;  
}  
  
int  Symmetry()     //对称性   看对应位置是否相等 
{  
int i,j;

    for(i = 1; i <= num; i++)  
    {  
        for( j = 1; j <= num; j++)  
        {  
            if(relation[i][j] != relation[j][i])  
            {  
                return 0;  
            }  
        }  
    }  
    return 1;  
}  
  
int  Transmission()  //传递性  如果具有传递性 即本身就是传递闭包 
{  
int i,j;

    Warshall();  
    for( i = 1; i <= num; i++)  
    {  
        for(j = 1; j <= num; j++)  
        {  
            if(A[i][j] != relation[i][j])  //具有传递性的集合  传递闭包就是自己 
            {  
                return 0;  
            }  
        }  
    }  
    return 1;  
}  
  
int  Irreflexivity()  //反自反性   和自反性一样 
{  
int i;

     for(i = 1; i <= num; i++)  
     {  
         if(relation[i][i] == 1)  
         {  
             return 0;  
         }  
     }  
     return 1;  
}  
  
int  Irsymmetry()    //反对称性   和反对称性一样 
{  
int i,j;

     for(i = 1; i <= num - 1; i++)  
     {  
         for(j = i + 1; j <= num; j++)  
         {  
              if(relation[i][j] == 1 && relation[j][i] == 1)  
              {  
                  if(i != j)  
                  {  
                      return 0;  
                  }  
              }  
         }  
     }  
     return 1;  
}  
  
void  Warshall()       //Warshall算法  
{  
int i,j;

    for(i = 1; i <= num; i++)  
    {  
        for( j = 1; j <= num; j++)  
        {  
            A[i][j] = relation[i][j];  
        }  
    }  
    for(i = 1; i <= num; i++)  
    {  
        for( j = 1; j <= num; j++)  
        {  
            if(A[j][i] == 1)  
            {  
                for(int k = 1; k <= num; k++)  
                {  
                    A[j][k] = A[j][k] + A[i][k];  
                    if(A[j][k] >= 1)  
                    {  
                        A[j][k] =  1;  
                    }  
                }  
            }  
        }  
    }  
  
}  

alotuscc
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
离散数学实验二
huzimu_的博客
02-15 3261
实验题目：生成树、环路空间、断集空间的求解 实验目的： 1、掌握无向连通图生成树的求解方法； 2、掌握基本回路系统和环路空间的求解方法； 3、掌握基本割集系统和断集空间的求解方法； 4、了解生成树、环路空间和断集空间的实际应用。 实验要求： 1、给定一无向简单连通图的相邻矩阵（例如：）。 2、输出此图的关联矩阵M。 3、求此图所有生成树的个数。 4、输出其中任意一颗生成树的相邻矩阵（默认第i行对应顶点vi）和关联矩阵（默认第i行对应顶点vi，第j列对应边ej）。 5、求此生成树对应的基本回路系统（输出形式
离散数学实验一
热门推荐
huzimu_的博客
02-12 1万+
实验题目：可简单图化、连通图、欧拉图和哈密顿图的判断 实验目的： 掌握可简单图化的定义及判断方法； 掌握连通图、欧拉图的判断方法； 掌握欧拉回路的搜索方法； 了解欧拉图的实际应用。 实验要求： 给定一非负整数序列（例如：(4,2,2,2,2)）。 判断此非负整数序列是否是可图化的，是否是可简单图化的。 如果是可简单图化的，根据Havel定理过程求出对应的简单图，并输出此图。 判断此简单图是否是连通的。 如果是连通图，判断此图是否是欧拉图。如果是欧拉图，请输出一条欧拉回路（输出形式如：v2->v1
离散数学实验一——关系
xuanyuanchun的博客
10-29 2402
离散数学实验一——关系 一、预习内容： 1、自反性：从给定的关系矩阵来断判关系R是否为自反是很容易的。若M（R的关系矩阵）的主对角线元素均为1，则R是自反关系；若M（R的关系矩阵）的主对角线元素均为0，则R是反自反关系；若M（R的关系矩阵）的主对角线元素既有1又有0，则R既不是自反关系也不是反自反关系。本算法可以作为判等价关系算法的子程序给出。 2、对称性：从给定的关系矩阵来判断关系R是否为对称是很容易的。若M（R的关系矩阵）为对称矩阵，则R是对称关系；若M为反对称矩阵，则R是反对称关系。因为R为对称的是等
离散数学实验三
AlbertDarren的博客
12-10 1320
离散数学实验三 1. 给定无向图的各边所关联的顶点对: (1) 确定每个顶点的度 (2) 构造这个图的关联矩阵 (3) 若将无向边改为有向边： 构造这个图的邻接矩阵 2.实验代码 (1) 确定每个顶点的度 # !/usr/bin/env python # -*- coding: utf-8 -*- """ @Time : 2020/11/13 09:58 @Author : Albert Darren @Contact : 2563491540@qq.com @File
离散数学实验四
Zero_hunter_kill的博客
04-17 956
A - 补图 Description 题目给出一个无向图，求该无向图关于完全图的相对补图，并求该补图的最大度和最小度。方便起见，用邻接矩阵表示该无向图。无向图的节点数不少于2并且不超过500. Input 多组输入，每组输入第一行是无向图中节点的数量即邻接矩阵的行列数n。接下来n行n列为该图的邻接矩阵。 Output 每组数据，首先输出n行n列表示补图的邻接矩阵。接下来一行两个用空格分隔的整数，分别代表补图的最大度和最小度。 Sample Input 4 0 0 1 1
OJ离散数学实验一
sky_kin的博客
03-25 728
1-1 A - 1.1联结词真值运算 #include<stdio.h> int main() { int p,q; while(~scanf("%d %d",&p,&q)) { if(p==1&&q==1) printf("1 "); else printf("0 "); if(p==0&&q==0) printf("0 "); else printf("1 "); if(p==1&&q==0) printf(
离散数学实验报告四——图的应用
xuanyuanchun的博客
10-29 2834
离散数学实验报告四——图的应用 预习内容： 1.图的基本概念 1.1图的定义：现实世界中许多现象能用某种图形表示,这种图形是由一些点和一些连接两点间的连线所组成。 1.2邻接点: 同一条边的两个端点。 1.3孤立点: 没有边与之关联的结点。 1.4邻接边: 关联同一个结点的两条边。 1.5孤立边: 不与任何边相邻接的边。 1.6自回路（环）：关联同一个结点的一条边（（v，v）或〈v，v〉）。 1.7平行边(多重边):关联同一对结点的多条边。 2. 图的矩阵表示 2.1邻接矩阵：设G＝〈V ,E〉是有n个结点
离散数学实验三 · 最短路径计算
u013266509的博客
04-15 1310
使用python编程Dijkstra算法，并实现最短路径问题。
离散数学实验题目-关系
无限迭代中......
05-30 3181
离散数学实验报告 计算机科学与技术系
离散数学实验报告1——关系.docx
10-29
实验的目的在于加深学生对离散数学中关系理论的理解，提高编程和算法设计能力。实验环境通常采用C++编程语言，利用关系矩阵进行计算和判断。实验步骤包括输入集合元素，构建关系矩阵，然后通过特定的函数判断自反性...
离散数学实验报告
12-09
实验一 联结词的运算 实验二 集合的运算 实验三 二元关系的性质判定 实验四 图的矩阵运算
南京邮电大学离散数学实验.zip
最新发布
05-15
南京邮电大学离散数学实验 lab1: 输入任意公式, 打印出该公式的真值表、主合取范式和主析取范式. lab2: 输入可以是具体的二元关系，也可以给定一个具体的集合，随机生成一个二元关系，根据二元关系性质及对应的判定...
大学离散数学实验集合运算.zip
01-06
【实验目的】掌握用计算机求集合的交、并、差和补运算的方法。 【实验内容】编程实现集合的交、并、差和补运算。 【实验原理和方法】 （1）用数组A，B，C，E表示集合。输入数组A，B，E（全集），输入数据时要求检查...
C语言字符串与变量名的转换
Lotuscc的博客
04-03 8977
#include #include #include <string.h> #include #include<stdio.h> using namespace std; #define to_str(name) (#name) #define TIMx_ARR(n) TIM##n##_ARR int main(void) { freopen(“G:\data.tx...
ST表 详解（C语言描述）
Lotuscc的博客
05-24 7427
    前面先给大家讲一下ST表的基础原理       ST表是一种常用算法，用于快速求区间的最值，当要大量计算区间最值时，使用ST表可以节省时间。     其复杂度为NlogN, 普通算法为N*N，缺点是不能在线修改值，（还有一种算法叫线段树可以，以后会讲）     ST[ i ][ j ] 的值为区间[ i, i + 2^j)  的最值，注意区间为左闭右开；    利用动态规划思想，区间[...
栈的建立和一些基本操作
Lotuscc的博客
05-27 4899
栈作为一种数据结构，由线性表演变而来，具有后进先出特性，有顺序储存和链式储存两种写法，这里写的是链式储存#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int ElementType; struct Node{ ElementType Element; struct Node *Next;};typedef struct Nod...
"C语言离散数学实验报告及源代码分析
为了掌握这些概念，我们进行了一系列实验，包括离散数学书验和离散数学实验。 离散数学书验主要是对离散数学课程中的理论知识进行验证和巩固。在这项任务中，我们需要使用C语言编写程序来计算给定的命题变元的合取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值