精华内容
下载资源
问答
  • 自反性传递性对称性
    千次阅读
    2020-12-11 23:19:52

    A={1,2,3}

    R1={<1,1>,<2,2>,<3,3>}

    R2={<1,3>}

    说明R1具有自反性.R2是反自反的。

    R1即是对称的,又是反对称的。

    R3={<1,1>,<1,2>,<2,1>}

    R4={<2,1>,<3,2>}

    对称的逆就是反对称。(<x,y>与<y,x>为对称,如果一个集合中只包括不同的<x,y>且没有<y,x>为反对称)

    R3是对称的。R4反对称。

    传递性与非传递性是互斥的。

    xRy ,yRz 存在关系<x,z>就是传递的。不存在就是非传递的。

    R4是传递的。

     

     

     

    更多相关内容
  • 本题判断二元关系的性质:自反性对称性传递性

    题目:本题判断二元关系的性质:自反性(reflexive)、对称性(symmetrical)、传递性(transitive)。

    输入格式:

    输入关系矩阵的阶数n(n<=10),接着输入如具有关系R的元素下标(i,j),输入 -1 -1,结束输入。判断该二元关系具有的性质。

    输出格式:

    输出二元关系a的性质,如果具有自反性性,则显示“a is reflexive”,如果具有对称性,则显示“a is transitive”,如果具有传递性,则显示“a is transitive”,如果具有自反性、对称性、传递性,则显示具有等价性“a is equivalent”。如果输入的n大于10,或者输入的数组元素下标i,j大于等于n(数组元素的下标应小于n),则显示"error",并结束程序。注意每个显示前后无空格,末尾回车。

    输入样例:

    在这里给出一组输入。例如:

    3
    1 0 2 0 0 1 2 1  0 2 1 2 -1 -1 
    

    输出样例:

    在这里给出相应的输出。例如:

    a is symmetrical

    一、知识点说明:

    一直以来用关系图理解自反对称传递等性质,放到关系矩阵中我就懵了

    首先关系图中有n个点 ,关系矩阵就用 n阶矩阵

    其次:三种性质都是蕴含式

    注意:记关系图中各点依次 为1,2,3....;关系矩阵中,有向边(关系)则用(i, j)表示

    最后三种性质特点(题目只考察自反对称传递,这里先不提反自反,反对称)

    1.自反性

    关系图,每个顶点都有环,则矩阵中表示(a, a)[即:有从该点自身到自身的有向边]

    关系矩阵,n阶矩阵,主对角线元素全为1.

    2.对称性

    关系图:如果两个顶点之间有边,则一定是一对方向相反的边

    (注意:这是蕴含式,如果前件不成立,两点之间连边都没有,同样满足对称性)

    关系矩阵:存在关系(a,b)且存在关系(b,a),即:矩阵为对称矩阵

    3.传递性

    关系图:如果顶点a到b有边,b到c有边,则a到c有边

    (同样注意:蕴含式,如果前件不成立,即不满足"a到b有边,且b到c有边",也满足传递性)

    关系矩阵:如果存在关系(a,b)且(b,c),则存在关系(a,c)

    二、代码:(分别用函数判断)

    最开始想着函数判断思路可能会更清晰,后来发现同学的代码不用函数更简洁

    #include<iostream>
    using namespace std;
    
    //1:判断自反性函数 :
    bool Reflexive(int ARR[10][10], int n)
    	{
    	int a1 = 0;//定义一个计数器,用于记录对角线为1的元素个数
    	for (int i = 0; i <= n; i++)
    		{
    		for (int j = 0; j <= n; j++)
    			{
    			if (ARR[i][j] == 1)//为1 的元素进入,准备判断各种性质
    				{
    				if (i == j)//其实两个条件可以合并
    					{
    					a1++;//满足自反的元素个数
    					}
    				}
    			}
    		}
    	if ( a1 == n)
    		{
    		return 1;//满足自反性,返回1
    		}
    	else
    		{
    		return 0;//不满足自反
    		}
    
    	}
    
    //2:判断对称性函数
    bool Symmetrical(int ARR[10][10], int n)
    	{
    	int B = 0;//记录关系数
    	int b= 0;//记录满足对称性的关系数目
    	for (int i = 0; i <= n; i++)
    		{
    		for (int j = 0; j <= n; j++)
    			{
    			if (ARR[i][j] == 1)
    				{
    				B++;//(1,1)这种对角线关系,也满足对称性定义
    				if (ARR[i][j] == 1 && ARR[j][i] == 1)
    					{
    					b++;//两个顶点间是双向边,则记录
    					}
    				}
    			}
    		}
    	if (b== B )//存在关系<i,j>,且存在<j,i>,双向边,则b==B
    		{
    		return 1;//满足对称
    		}
    	else
    		{
    		return 0;//不对称
    		}
    	}
    
    
    //3:判断传递性函数 :
    bool Transitive(int ARR[10][10], int n)
    	{
    	int C1 = 0;
    	int c1 = 0;
    	for (int i = 0; i <= n; i++)
    		{
    		for (int j = 0; j <= n; j++)
    			{
    			if (ARR[i][j] == 1)//为1 的元素进入,准备判断各种性质
    				{
    				for (int k = 0; k <= n; k++) //用于(j,k)
    					{
    					if (ARR[j][k] == 1)
    						{
    						C1++;//记录前件“顶点a到b有边,且b到c有边”	的次数					 
                            if (ARR[i][k] == 1)
    							{
    							c1++;//记录后件“a到c有边”的次数
    							}
    						}
    					}
    				}
    			}
    		}
    
    	if (c1 == C1 || C1 == 0)//前件后件均成立,顶点a到b有边,b到c有边,且a到c有边,则蕴含式为真,满足传递(c1==C1);或者蕴含式前件都不满足,即不存在“顶点a到b有边,且b到c有边”,蕴含式也为真,亦满足传递性(C1==0);
    		{
    		return 1;//满足传递性
    		}
    	else
    		{
    		return 0;//不满足传递性
    		}
    	}
    
    
    int main()
    	{
    //一:输入元素阶数n,以及元素关系(a,b),初始化关系 为1
    	int arr[10][10] = { 0 };
    	int n, a = 0, b = 0;
    	cin >> n;
    	while (a != -1 && b != -1)//输入(-1,-1)时,结束输入
    		{
    		cin >> a >> b;
    		if (n > 10 || a >= n || b >= n)//解决题目中[如果输入的n大于10,或者输入的数组元素下标i,j大于等于n(数组元素的下标应小于n),则显示"error",并结束程序。]问题
    			{
    			cout << "error";
    			return 0;
    			}
    		arr[a][b] = 1;//初始化该关系为1
    		}
    
    //二:调用函数判断并输出性质
    	int A, B, C;//记录性质,满足对应性质为1,不满足为0
    	A = Reflexive(arr, n);
    	B = Symmetrical(arr, n);
    	C = Transitive(arr, n);
    
    //这题输出格式,满足几条性质就输出几条性质;三种均满足,则输出三条性质外,还需格外输出等价性。
    	if (A == 1)
    		{
    		cout << "a is reflexive" << endl;
    		}
    	if (B == 1)
    		{
    		cout << "a is symmetrical" << endl;
    		}
    	if (C == 1)
    		{
    		cout << "a is transitive" << endl;
    		}
    
    	if (A == 1 && B == 1 && C == 1)//三种性质均满足,格外输出等价性
    		{
    		cout << "a is equivalent";
    		}
    
    	}

    有空了重做,简化了再来

    展开全文
  • //分别将自反性对称性传递性的编号为Func1、Func2,Func3。 #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;fstream&gt; using namespace std; const int LEN = 140...
    暂时当草稿存放在这里,后面再补充
    
    
    //分别将自反性、对称性、传递性的编号为Func1、Func2,Func3。
    #include <iostream>
    #include <cstring>
    #include <fstream>
    using namespace std;
    
    const int LEN = 140 + 10;
    int arr[LEN][2+10];      //存储集合元素
    int relation[LEN][LEN];  //关系矩阵
    int nnn; //集合元素个数
    int num; //集合关系个数
    void Func1();
    void Func2();
    void Func3();
    
    int main()
    {
     //   freopen("datain.txt", "r", stdin);
        cout << "请输入集合中的元素个数 : " << endl;
        cin >> nnn;
        cout << "请输入集合中的关系个数 : " << endl;
        cin >> num;
        cout << "集合中一共有" << num << "对关系" << "," << num*2 <<"个元素(请以整数形式输入) : " << endl;
        memset(arr, 0, sizeof(arr));   //用数组做参数传递给标准函数memset(),以让其将数组设置成全0:
        memset(relation, 0, sizeof(relation)); //这里不懂得话可以参考https://blog.csdn.net/qq_37796444/article/details/80181632
        int num1, num2;
        for(int i = 1; i <= num; i++)
        {
            cin >> num1 >> num2;
            arr[i][1] = num1;
            arr[i][2] = num2;
            relation[num1][num2] = 1;
        }
    
        cout << "输出关系矩阵 : " << endl;
        for(int i = 1; i <= nnn; i++)
        {
            for(int j = 1; j <= nnn; j++)
            {
                cout << relation[i][j] << "     ";
            }
            cout << endl;
        }
        cout << endl;
    
        cout << "判断结论 : " << endl;
        //判断是否满足自反性
        Func1();
        //判断是否满足对称性
        Func2();
        //判断是否满足传递性
        Func3();
        return 0;
    }
    
    void Func1()   //判断是否满足自反性
    {
        bool flag = true;
        for(int i = 1; i <= nnn; i++)
        {
            if(relation[i][i] != 1)
            {
                flag = false;
                break;
            }
        }
        if(flag == true)
        {
            cout << "满足自反性" << endl;
        }
        else
        {
            cout << "不满足自反性" << endl;
        }
    }
    
    void Func2()  //判断是否满足对称性
    {
        bool flag = true;
        for(int i = 1; i <= nnn; i++)
        {
            for(int j = 1; j <=nnn; j++)
            {
                if(relation[i][j] != relation[j][i])
                {
                    flag = false;
                }
            }
        }
        if(flag == true)
        {
            cout << "满足对称性" << endl;
        }
        else
        {
            cout << "不满足对称性" << endl;
        }
    }
    
    void Func3()  //判断是否满足传递性
    {
        bool flag = true;
        for(int i = 1; i <= num - 1; i++)  //num表示关系个数
        {
            for(int j = 2; j <= num; j++)
            {
                if(arr[i][2] == arr[j][1])   //arr数组表示存储集合元素
                {
                    int num1 = arr[i][1], num2 = arr[j][2];
                    if(relation[num1][num2] != 1)
                    {
                        flag = false;
                        break;
                    }
                }
            }
            if(flag == false)
                break;
        }
        if(flag == true)
        {
            cout << "满足传递性" << endl;
        }
        else
        {
            cout << "不满足传递性" << endl;
        }
    }
    

    展开全文
  • Determine-the-nature-of-the-set-of-binary-relations 对任意二元关系集合,判定其是否具有自反性对称性传递性、反对称性、反自反性,如果具有某些性质,需输出至少一个反例
  • i++) { if (arr[i][i] == 0) { System.out.println("反自反性"); return; } } System.out.println("自反性"); } public void isS() { for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { if (arr[i][j] == 1) ...
    • 给定一个整数表示元素集合个数
    • 会随机生成num个序偶,打印出来。并自动判断关系
    • 入输入0,表示退出。
    import java.util.Random;
    import java.util.Scanner;
    
    public class Test {
        public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
            int i=scanner.nextInt();
            while (i!=0){
                new ZuoYe(i);
                i=scanner.nextInt();
            }
            System.out.println("退出");
        }
    }
    
    
    class ZuoYe {
        int Max;
        int[][] arr;
        int num;
        Random random;
    
        public ZuoYe(int max) {
            this.Max = max;
            arr = new int[max][max];
            this.random = new Random();
            this.num = this.random.nextInt(max * max) ;
            int row;
            int line;
            if (num==0){
                System.out.print("空");
            }else {
                for (int i = 0; i < this.num; i++) {
                    row = random.nextInt(max);
                    line = random.nextInt(max);
                    if (arr[row][line] == 1) {
                        --i;
                    } else {
                        arr[row][line] = 1;
                        if (i==this.num-1)
                            System.out.print(new Node(row+1,line+1).toString());
                        else
                            System.out.print(new Node(row+1,line+1).toString()+" ,");
                    }
                }
            }
            System.out.println();
    
            isR();
            isS();
            isT();
        }
    
        public void isR() {
            for (int i = 0; i < this.Max; i++) {
                if (arr[i][i] == 0) {
                    System.out.println("反自反性");
                    return;
                }
            }
            System.out.println("自反性");
        }
    
        public void isS() {
            for (int i = 0; i < this.Max; i++) {
                for (int j = 0; j < this.Max; j++) {
                    if (arr[i][j] == 1) {
                        if (arr[j][i] == 0) {
                            System.out.println("反对称性");
                            return;
                        }
                    }
                }
            }
            System.out.println("对称性");
        }
    
        public void isT() {
            for (int a = 0; a < this.Max; a++) {
                for (int b = 0; b < this.Max; b++) {
                    if (arr[a][b] == 1) {
                        for (int c = 0; c < this.Max; c++) {
                            if (arr[b][c] == 1) {
                                if (arr[a][c] == 0) {
                                    System.out.println("没有传递性");
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            System.out.println("具有传递性");
        }
        public static class Node{
            int i;
            int j;
            public Node(int i,int j){
                this.i=i;
                this.j=j;
            }
    
            @Override
            public String toString() {
                return "< " +
                        i +
                        ", " + j +
                        " >";
            }
        }
    }
    
    展开全文
  • 同时提供了一个验证传递性的方法,化特殊到一般,把任何形式关系矩阵统统转换为方阵(基于善意的判断这一概念)从而实现验证传递性。(基于VS2010) #include #include//控制格式化输出 using namespace std; class ...
  • 等价关系的自反性对称性传递性分别有什么作用? - 知乎
  • 判断是否输入的矩阵是否为方阵,在是方阵的基础上判断是否具有对称性,反对称性和自反性。 对称矩阵:一个方形矩阵,其转置矩阵和自身相等。 对称矩阵是指以主对角线为对称轴,各元素对应相等的矩阵。用线性代数书上...
  • 在 JDK 7 版本以上, Comparator 要满足自反性传递性对称性,不然 Arrays . sort ,Collections . sort 会报 IllegalArgumentException 异常。说明:1 ) 自反性: x , y 的比较结果和 y , x 的比较结果相反。...
  • 求关系的自反对称传递,简单的代码。可以正常的运行,是课上的实验作业
  • ua中对table的排序一般是用lua自带的table.sort()函数排序,一般采用自己写的排序的方式,以下来说一说 table.sort()排序和在工作中遇到的问题  1.排序的方式 table.sort(tbl,function(a,b) return a > b...
  • 学会用C语音编写自反闭包,对称闭包,传递闭包,加深对关系运算的理解。
  • 集合论—关系的自反对称传递闭包

    万次阅读 多人点赞 2019-06-21 21:52:33
    关系的自反对称传递闭包定义 设R\text{R}R是非空集合AAA上的关系,R\text{R}R的自反(对称传递)闭包是AAA上的关系R′\text{R}&#x27;R′,且R′\text{R}&#x27;R′满足以下条件: R′\text{R}&#...
  • 离散数学自反对称传递闭包

    千次阅读 2021-07-10 11:28:43
  • 性质:自反、反自反对称、反对称、传递、互斥

    千次阅读 多人点赞 2020-04-09 21:23:05
    自反: 如果a是A的元素,那么<a,a>是R的元素 反自反:如果a是A的元素,那么<a,a>不是R的元素 对称: 如果<a,b>是R的元素,那么<b,a>是R的元素 反对称:如果<a,b>,<b,a>是R的...
  • ++i2) { // 将满足自反性的去除 coverRelationMatrix[i2][i2] = false; // 将满足传递性的去除 if (coverRelationMatrix[i][i1] && coverRelationMatrix[i1][i2]) { coverRelationMatrix[i][i2] = false; } } } } }...
  • 如何判断关系是否自反,反自反,对称,反对称,传递

    万次阅读 多人点赞 2019-06-19 11:10:23
    自反与反自反可以同时满足。 下面来看如何通过关系矩阵,判断是否是传递关系。 传递关系,在关系矩阵能一眼直接看出,但是同样可以按照步骤来检查。 方法是: 按从上到下,从左到右,逐一检查某行...
  • /***************自反性判断******************/ for(i=0;i;i++) { if(u[i][i]!=1)break; if(i==e-1)printf("关系A是自反的\n"); } for(i=0;i;i++) { if(u[i][i]==1)break;  if...
  • 3.1     集合与表示: 3.2     集合: 3.3     集合的计数与划分: 3.4     ...集合的计数:例题
  • r(R)=R U Ix s(R)=R U Ix t(R)=RUR^2UR^3……
  • 输出格式: 输出二元关系a的性质,如果具有自反性性,则显示“a is reflexive”,如果具有对称性,则显示“a is transitive”,如果具有传递性,则显示“a is transitive”,如果具有自反性对称性传递性,则显示...
  • /*2.1写一个程序,测试关系是否是自反对称的*/ //怎么让一个确定长宽的二维数组做函数的参数??????? #include<stdio.h> #define N 5 int a[N][N]; //在判断对称时使用 int leijia( int n ) { int ...
  • 本程序验证集合内的等价关系 检验是否满足自反关系 检验是否满足对称关系 检验是否满足传递关系
  • Wrashall算法,自反性对称性的实现

    千次阅读 2018-05-19 23:09:30
    如:自反性对称性传递性以及Wrashall算法,下面将用Java实现 一.处理二元关系的类(ArraysSetOperation): public class ArraysSetOperation { private int[][] array; private int[][] array2 = new int...
  • 我们把关系R的闭包称作R‘,自反,(对称)(传递)闭包就是能满足该自反(对称传递)性质的关系R的最小扩充。 r(R):自反闭包 r:reflexive  s(R):对称闭包 s:symmetry t(R):传递闭包 t:transfer ...
  • 关系的求逆与闭包关系的求逆关系求逆运算的性质关系的闭包如果R满足某关系,但是R'满足闭包的计算方法 关系的求逆 R是A到B的关系,Rc(R−1)={<y,x>∣<x,y>∈R} R是A到B的关系,R^c(R^{-1})=\{<y,x&...
  • 离散数学,自反性

    千次阅读 2019-04-10 17:48:19
    print ('是自反性') elif numpy.all(B==0): print ('是反自反性') if (A==A.T).all(): print('是对称性') flag1=0 for i in range(0,a): for j in range(0,a): if A[i,j]==1 and i!=j and A[j,i]==0: flag1=1 ...
  • 离散实验报告求有限集上给定关系的自反对称传递闭包
  • 平时很少做离散题,练练[CODE]#include #include #include int locate(int *element,int len,int value){for(int i=0;iif(element[i]==value)return i;return -1;}int main(){int i,n,m,x,y,px,py;...
  • 反对称传递

    2013-12-18 16:21:48
    c语言编写离散判断是否满足自反(isReflexive),如不是求出自反闭包(reflexiveClosure) 判断是否满足对称(isSymmetric),如满足求出对称闭包(symmetricClosure) 判断是否满足反对称(isAntiSymmetric) 求...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,292
精华内容 9,316
关键字:

自反性传递性对称性