离散数学---判断矩阵:自反性,反自反性,对称性得到矩阵的自反闭包,对称闭包。

目录

1-自反性,反自反性,对称性

2--矩阵的自反闭包,对称闭包


1-自反性,反自反性,对称性

题目:从键盘输入集合A的元素值,键盘输入A到A 关系矩阵M。
判断该关系矩阵M是否具有
(1)自反性、
(2)反自反性、
(3)对称性、
输出以上各性质的判定结果。

    1ed70b765eb74cc58b110d228dbbeaf3.png

 那么对于这个程序的执行,我们想法是什么?

  • 创建一个二维数组,将1 0这样的元素储存进去
  • 进行三次判断
  • 如果if (i == j && arr1[i][j] == 1)是不是判断一次可以判断对角线都是1 即满足自反
  • 如果if (i == j && arr1[i][j] == 0) 是不是判断一次可以判断对角线都是0 即满足反自反
  • 如果 if (arr1[i][j] == arr1[j][i] == 1) 是不是可以判断满足对称性呢
  • 这样想真的没错吗? 停下来想一下
  • 其实思路是没错的,但是整体还是不正确,因为你要判断对角线所有的元素都是1或者0,和那个所有的元素都是(i,j)对称的,所以这个时候你加一个m++,从0 开始,如若是的且满足 m = n(你输入矩阵的大小)那么其实是满足的

那么对于上述的分析可知,我们自然可可以设置三个函数,分别来对各个来进行判断,并且进行输出,记住我们是不需要返回值的void类型

void Reflexivity(int x, int y); //判断是否具有自反性

void Anti_reflexivity(int x, int y);//判断是否具有反自反性

void symmetry(int x, int y);//判断是是否具有对称性

然后利用for循环嵌套输入数值后就进行函数的调用

Reflexivity(n, n);//调用判断自反性的函数

     Anti_reflexivity(n, n);//调用判断反自反性的函数

     symmetry(n, n);//调用判断对称性的函数

 你这个时候可能疑问,为什么我没有把数组直接调用过去呢?

是因为我采用了全局数组的概念,反正这个是公共的大家都能用,反正三个函数大家都用的到,何乐而不为呢?

第一个是不用函数,直接进行定义的部分,如下:

#include<stdio.h>
#define N 100 //使用宏定义给数组一个较大的值
int main()
{   
	int n, i, j, arr1[N][N];
	int flag1=0, flag2=0, flag3 = 0;
	int n1=0, n2=0;
	printf("请输入矩阵的长度:");
	scanf("%d", &n);//输入矩阵的长度,行列相同
	for (i = 0; i < n; i++)//循环行
	{
		for (j = 0; j < n; j++)//循环列
		{
			scanf("%d", &arr1[i][j]);//循环的目的就是元素的输入
		}
	}

	for (i = 0; i < n; i++)//同样是循环,但是是为了标注信息
	{
		for (j = 0; j < n; j++)//列循环
		{
			if (i == j&&arr1[i][j]==1){
				flag1 = 1;
				n1++;
			}	
			
			if (i == j && arr1[i][j] == 0) //要判断四次啊
			{
				flag2 = 1;
				n2++;
			}

			if (arr1[i][j] == arr1[j][i] == 1)//如果在二维数组中出现1
				flag2 = 1;
		}
	}
	
	if (flag1 == 1&&n1==4)
		printf("111\n");
	else
		printf("0000\n");

	if (flag2 == 1&&n2==4)
		printf("2222\n");
	else
		printf("3333\n");

	if (flag3 == 1)
		printf("444\n");
	else
		printf("5555\n");
}
//以上是离散数学的初级版本

一下是调用的其中的一个函数部分.

void Reflexivity(int x, int y) {
	int i, j, flag1=1,n1=0;
	for (i = 0; i < x; i++)//外层循环
	{
		for (j = 0; j < y; j++)//内层循环
		{
			if (i == j && arr1[i][j] == 1) {//对角线元素相等且为1
				flag1 = 1;
				n1++; //n的作用是判断是否每个对角线元素 1 都是存在的
			}
		}
	}
	if (flag1 == 1 && n1 == n)
		printf("关系矩阵A具有自反性\n");
	else
		printf("关系矩阵A不具有自反性\n");
}

整体的代码如下:()

#include<stdio.h>
#define N 100 
int arr1[N][N];
int n;
void Reflexivity(int x, int y); 
void Anti_reflexivity(int x, int y);
void symmetry(int x, int y);
int main()
{   
	int i, j;
	printf("请输入矩阵的长度:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)//循环列
		{
			scanf("%d", &arr1[i][j]);
		}
	}
	Reflexivity(n, n);
	Anti_reflexivity(n, n);
	symmetry(n, n);

}
void Reflexivity(int x, int y) {
	int i, j, flag1=1,n1=0;
	for (i = 0; i < x; i++)//外层循环
	{
		for (j = 0; j < y; j++)//内层循环
		{
			if (i == j && arr1[i][j] == 1) {
				flag1 = 1;
				n1++; 
			}
		}
	}
	if (flag1 == 1 && n1 == n)
		printf("关系矩阵A具有自反性\n");
	else
		printf("关系矩阵A不具有自反性\n");
}
void Anti_reflexivity(int x, int y) {
	int i, j, flag2=0, n2 = 0;
	for (i = 0; i < x; i++)//行(外)循环
	{
		for (j = 0; j < y; j++)//列(内)循环
		{
			if (i == j && arr1[i][j] == 0) {
				flag2 = 1;
				n2++; 
			}
		}
	}
	if (flag2 == 1 && n2 == n)
		printf("关系矩阵A具有反自反性\n");
	else
		printf("关系矩阵A不具有反自反性\n");
}
void symmetry(int x, int y) {
	int i, j, flag3=0,n3=0;
	for (i = 0; i < x; i++)
	{
		for (j = 0; j < y; j++)
		{
			if (arr1[i][j] == arr1[j][i] == 1)
			{
				flag3 = 1; 
				n3++;
			}
		}
	}
	if (flag3 == 1&& n3==n )
		printf("关系矩阵A具有对称性\n");
	else
		printf("关系矩阵A不具有对称性\n");
}

运行的效果: 

 d4347e13bb5147ef9212e11c4a7a420d.png

2--矩阵的自反闭包,对称闭包

题目3:
从键盘输入集合A的元素值,键盘输入A
到A 关系矩阵M。
输出关系矩阵M的
(1)自反闭包矩阵、
(2)对称闭包矩阵

 

dbb2c88ab62b42c9ba81ce15efe089da.png

 则有关闭包,还有上面的那个图形,想一想你会定义几个二维数组呢?

三个第一个是为了存放初始的元素,也就是输入的元素,第二个数组和初始数组相加,如果二者之和大于1 那就是1 ,否则就是 0 ,不要说1 +1 =2 哈,第三个数组则是得到其转置。

  • 创建三个二维数组,然后利用宏定义来给定义数组的长度
  • 初始数组的数值的输入
  • 进行二重循环来对数组2和数组3 进行处理
  • 同样是二重循环来对其闭包的输出
  • 结束.

这是核心代码:

for (i = 0; i < n; i++)//同样是循环,但是是为了标注信息

    {

         for (j = 0; j < n; j++)//列循环

         {

             if (i == j) arr2[i][j] = 1;//arr2为恒等关系

             else arr2[i][j] = arr1[i][j];//和数组1是一样

             if (arr1[i][j] == 1)//如果在二维数组中出现1

             {                  

                  arr3[i][j] = 1;//将其赋值为1

                  arr3[j][i] = 1;//那个数组3的转置矩阵

             }

         }

    }

整体代码的收尾工作:

#include<stdio.h>
#define N 100 //使用宏定义给数组一个较大的值
int main()
{   
	int n, i, j, arr1[N][N], arr2[N][N], arr3[N][N] = { 0 };
	printf("请输入矩阵的长度:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &arr1[i][j]);
		}
	}
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			if (i == j) arr2[i][j] = 1;
			else arr2[i][j] = arr1[i][j];
			if (arr1[i][j] == 1)
			{                   
				arr3[i][j] = 1;
				arr3[j][i] = 1;
			}
		}
	}
	printf("自反闭包矩阵如下:\n");
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			printf("%d ", arr2[i][j]);
		}
		printf("\n");
	}
	printf("对称闭包矩阵如下:\n");
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			printf("%d ", arr3[i][j]);
		}
		if (i < n - 1) printf("\n");
	}
}

 运行的截图

9d561b59783b470487d7faf5318c06de.png

 

 

  • 2
    点赞
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: 在数学和计算机科学中,关系是描述元素之间的某种联系或属性的概念。其中,自反对称以及传递闭包关系的三个重要特性之一。 首先,自反关系是指集合中的每个元素都和自己相联。换句话说,对于关系R和集合S中的任意元素a,若(a, a)属于R,则关系R是自反的。在Java中,我们可以通过编写代码来判断一个关系是否自反的。例如,我们可以使用for-each循环遍历集合中的每个元素,并检查是否存在对应的自反关系。若所有的元素都满足关系要求,则关系自反的。 其次,对称关系是指如果元素a与元素b相联,则元素b与元素a也相联。简而言之,对于关系R和集合S中的任意元素a和b,若(a, b)属于R,则(b, a)也属于R,则关系R是对称的。在Java中,我们可以使用条件语句来实现对称关系判断。如果R关系存在a和b的相联,我们可以根据条件判断语句来判断是否存在b和a的相联。 最后,传递闭包是指如果元素a与元素b相联,并且元素b与元素c相联,则元素a与元素c也相联。换句话说,对于关系R和集合S中的任意元素a、b和c,若(a, b)以及(b, c)属于R,则(a, c)也属于R,则关系R是传递的。在Java中,我们可以使用嵌套循环来判断传递闭包的存在。首先,我们可以使用第一个循环遍历集合中的每个元素a,然后在第二个循环中使用条件判断语句来判断元素a和其他元素之间的联。 综上所述,自反对称和传递闭包是数学中描述关系特性的重要概念。在Java中,我们可以通过编写相的代码来判断一个关系是否满足这些特性。 ### 回答2: 自反(reflexive)关系是指对于集合中的每个元素,都存在一对元素是相的。在数学中,我们可以使用关系判断符号“<=”来表示自反性。例如,对于一个集合A,如果a∈A,则必定有a<=a。 在Java中,我们可以使用关系运算符“==”来判断两个元素是否相等,进而判断关系是否自反的。例如,我们可以构建一个contains方法来验证一个集合是否具有自反关系: ```java public class MathRelations { public static <T> boolean isReflexive(Set<T> set) { for (T element : set) { if (!set.contains(element)) { return false; } } return true; } } ``` 对称(symmetric)关系是指如果对于集合中的每一对元素a和b,如果a与b相,则b与a也是相的。在数学中,我们可以使用关系判断符号“=”来表示对称性。例如,对于一个集合A,如果a,b∈A且a=b,则必定有a=b和b=a。 在Java中,我们可以使用equals方法来判断两个元素是否相等,进而判断关系是否对称的。例如,我们可以构建一个isSymmetric方法来验证一个集合是否具有对称关系: ```java public class MathRelations { public static <T> boolean isSymmetric(Set<T> set) { for (T a : set) { for (T b : set) { if (set.contains(a) && !set.contains(b)) { return false; } if (set.contains(b) && !set.contains(a)) { return false; } } } return true; } } ``` 传递闭包(transitive closure)关系是指如果对于集合中的每一对元素a、b、c,如果a与b相且b与c相,则a与c也是相的。在数学中,我们可以使用关系判断符号“→”来表示传递闭包性质。例如,对于一个集合A,如果a,b,c∈A且a→b且b→c,则必定有a→c。 在Java中,我们可以使用自定义方法来判断关系是否是传递闭包的。例如,我们可以构建一个isTransitive方法来验证一个集合是否具有传递闭包关系: ```java public class MathRelations { public static <T> boolean isTransitive(Set<T> set, Relation<T> relation) { for (T a : set) { for (T b : set) { if (relation.isRelated(a, b)) { for (T c : set) { if (relation.isRelated(b, c) && !relation.isRelated(a, c)) { return false; } } } } } return true; } public interface Relation<T> { boolean isRelated(T a, T b); } } ``` 以上是基于Java的三种数学关系性质的简单实现示例,用于验证给定集合是否满足自反对称和传递闭包的要求。 ### 回答3: 在数学中,关系是用来描述事物之间的联系和联系的一种概念。常见的关系包括自反对称和传递性关系。在Java中,我们可以使用代码实现这些关系自反关系是指对于某个集合中的每个元素,都满足这个元素与自身之间存在某种关系。在Java中,我们可以通过遍历集合中的每个元素,判断它们是否满足这个关系判断自反关系的成立。 对称关系是指如果集合中的元素a与元素b之间存在某种关系,那么元素b与元素a之间也存在这个关系。使用Java代码来实现对称关系,可以通过遍历集合中的每对元素进行判断,如果满足这个关系,则可以认为对称关系成立。 传递闭包是指如果集合中的元素a与元素b之间存在某种关系,同时元素b与元素c之间也存在这个关系,那么元素a与元素c之间也存在这个关系。在Java中,我们可以通过嵌套循环遍历集合中的每对元素进行判断,如果满足这个关系,则可以认为传递闭包成立。 总结起来,Java可以通过循环遍历集合中的元素,判断它们是否满足自反对称和传递性关系来实现这些关系。具体的实现代码可能会因具体的关系而有所不同,但这些基本的思路可以帮助我们理解如何在Java中实现这些关系
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

i-阿松!

请给我一毛钱

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值