精华内容
下载资源
问答
  • 判断关系性质

    2013-12-22 14:09:09
    这是判断关系性质的代码,自己写的,大家看看
  • 二元关系关系性质判断

    千次阅读 多人点赞 2018-06-08 22:00:19
    今天离散老师布置了一个编程作业:用代码实现关系性质判断。然后我就结合所学知识写了写,如果哪里有不足欢迎批评指正。自反性:∀x∈A,有<x,x>∈R。关系矩阵特点:主对角线元素全为1.关系图的特点...

    今天离散老师布置了一个编程作业:用代码实现关系性质的判断。然后我就结合所学知识写了写,如果哪里有不足欢迎批评指正。

    自反性:∀x∈A,有<x,x>∈R。

    关系矩阵特点:主对角线元素全为1.

    关系图的特点:图中每个顶点都有环。

    代码:

    int refl(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            if(!e[i][i]){
                flag=true;
                break;
            }
        }
        if(flag) return 0;
        else return 1;
    }

    反自反性:∀x∈A,有<x,x>R。

    关系矩阵特点:主对角线元素全为0.

    关系图特点:图中每个顶点都没环。

    代码:

    int irrefl(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            if(e[i][i]){
                flag=true;
                break;
            }
        }
        if(flag) return 0;
        else return 1;
    }

    对称性:若<x,y>∈R,则<y,x>∈R。

    关系矩阵特点:矩阵为对称矩阵。

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

    代码:

    int sym(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(e[i][j]&&!e[j][i]){
                    flag=true;
                }
            }
            if(flag) break;
        }
        if(flag) return 0;
        else return 1;
    }

    反对称性:

    若<x,y>∈R,且x不等于y,则<y,x>R。

    关系矩阵特点:如果r[i][j]=1,且i不等于j,则r[j][i]=0.

    关系图特点:如果两个顶点之间有边,一定是一条有向边。

    代码:

    int irsym(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j){
                    if(e[i][j]&&e[j][i]){
                        flag=true;
                        break;
                    }
                }
                else continue;
            }
            if(flag) break;
        }
        if(flag) return 0;
        else return 1;
    }

    传递性:

    若<x,y>∈R,且<y,z>∈R,则<x,z>∈R。

    关系图特点:如果顶点xi到顶点xj有边,xj到xk有边,则从xi到xk有边。

    代码:

    int tra(){
        memset(book,0,sizeof(book));
        for(int k=1;k<=n;k++){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    if(e[i][k]&&e[k][j]){
                       book[i][j]=1;//表示两点之间可以到达
                    }
                }
            }
        }
        bool flag=false;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(book[i][j]){
                    flag=true;
                    break;
                }
            }
            if(flag) break;
        }
        if(flag) return 1;
        else return 0;
    }

    总代码:

    #include<bits/stdc++.h>
    using namespace std;
    int n,m;//n代表集合中元素的个数,m表示集合r中序偶的个数
    int e[101][101];//关系矩阵
    int a[101];//集合a
    int vis[101][101],book[101][101];
    struct node {
    	int x, y;//x为第一元素,y为第二元素
    }r[100010];//集合r的序偶
    int refl(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            if(!e[i][i]){
                flag=true;
                break;
            }
        }
        if(flag) return 0;
        else return 1;
    }
    int irrefl(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            if(e[i][i]){
                flag=true;
                break;
            }
        }
        if(flag) return 0;
        else return 1;
    }
    int sym(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(e[i][j]&&!e[j][i]){
                    flag=true;
                }
            }
            if(flag) break;
        }
        if(flag) return 0;
        else return 1;
    }
    int irsym(){
        bool flag=false;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j){
                    if(e[i][j]&&e[j][i]){
                        flag=true;
                        break;
                    }
                }
                else continue;
            }
            if(flag) break;
        }
        if(flag) return 0;
        else return 1;
    }
    int tra(){
        memset(book,0,sizeof(book));
        for(int k=1;k<=n;k++){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    if(e[i][k]&&e[k][j]){
                       book[i][j]=1;//表示两点之间可以到达
                    }
                }
            }
        }
        bool flag=false;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(book[i][j]){
                    flag=true;
                    break;
                }
            }
            if(flag) break;
        }
        if(flag) return 1;
        else return 0;
    }
    int main() {
    	while (~scanf("%d%d",&n,&m)) {
            getchar();
            memset(vis,0,sizeof(vis));
    		memset(e,0,sizeof(e));
    		for (int i = 1; i <= n; i++) {
                scanf("%d",&a[i]);//输入集合a
    		}
            getchar();
    		for(int i=1;i<=m;i++){
                scanf("%d %d",&r[i].x,&r[i].y);//输入集合r的第一第二元素
                vis[r[i].x][r[i].y]=1;
    		}
    		//生成关系矩阵
    		for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    if(vis[a[i]][a[j]]) e[a[i]][a[j]]=1;
                }
    		}
    		if(refl()){
                printf("具有自反性\n");
                printf("关系矩阵为\n");
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        printf("%d ",e[i][j]);
                    }
                    printf("\n");
                }
    		}
    		if(irrefl()){
                printf("具有反自反性\n");
                printf("关系矩阵为\n");
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        printf("%d",e[i][j]);
                    }
                    printf("\n");
                }
    		}
    		if(sym()){
                printf("具有对称性\n");
                printf("关系矩阵为\n");
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        printf("%d",e[i][j]);
                    }
                    printf("\n");
                }
    		}
    		if(irsym()){
                printf("具有反对称性\n");
                printf("关系矩阵为\n");
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        printf("%d",e[i][j]);
                    }
                    printf("\n");
                }
    		}
    		if(tra()){
                printf("具有传递性\n");
                printf("关系矩阵为\n");
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        printf("%d",e[i][j]);
                    }
                    printf("\n");
                }
    		}
    	}
    	return 0;
    }
    

    展开全文
  • 判断关系性质:判断关系性质--离散课程设计.有关离散的程序,用C++编写的.
  • //自反判断函数 int zifan(int r[Size][Size], int m, int n) { int i,j,count=0; for(i=0; i; i++) { for (j=0; j; j++) { if(i==j&&r[i][j]==1) { count++; } } } if(count==m) { ...
  • 离散数学实验:关系性质判断

    千次阅读 2020-05-08 19:23:35
    熟悉关系的性质,掌握求判断关系性质的方法。 二、实验内容 本实验要求从键盘输入一个关系的关系矩阵,判断该关系是否是自反的、对称的、传递的、反自反的、反对称的。用C语言或MATLAB实现。 三、实验源程序 #...

    一、实验目的

    熟悉关系的性质,掌握求判断关系性质的方法。

    二、实验内容

    本实验要求从键盘输入一个关系的关系矩阵,判断该关系是否是自反的、对称的、传递的、反自反的、反对称的。用C语言或MATLAB实现。

    三、实验源程序

    #define _CRT_SECURE_NO_WARNINGS//避免scanf编译不通过
    #include <stdio.h>
    #include <stdlib.h>
    void Input();//输入关系矩阵
    bool Ref();//判断是否自反
    bool NoRef();//判断是否反自反
    bool Sym();//判断是否对称
    bool NoSym();//判断是否反对称
    bool Tra();//判断是否传递
    int matrix[100][100]{ 0 };
    int line;
    int main()
    {
    	Input();
    	if (Ref())
    		printf("该关系是自反的\n");
    	if (NoRef())
    		printf("该关系是反自反的\n");
    	if (Sym())
    		printf("该关系是对称的\n");
    	if (NoSym())
    		printf("该关系是反对称的\n");
    	if (Tra())
    		printf("该关系是传递的!\n");
    	return 0;
    }
     
    void Input()
    {
    	printf("请输入关系矩阵的行列数(行列数小于等于100):\n");
    	scanf("%d", &line);
    	if (line > 100 || line < 1)//判断行列数是否合法
    	{
    		printf("非法输入!\n");
    		exit(0);
    	}
    	printf("请输入关系矩阵:\n");
    	for (int i = 0;i < line;i++)
    	{
    		for (int j = 0;j < line;j++)
    		{
    			scanf("%d", &matrix[i][j]);
    			if (matrix[i][j] >= 2 || matrix[i][j] < 0)
    			{
    				printf("输入关系矩阵错误\n");
    				exit(0);
    			}
    		}
    	}
    }
    bool Tra()
    {
    	for (int i = 0;i < line;i++)
    	{
    		for (int j = 0;j < line;j++)//二重数组遍历关系矩阵
    		{
    			if (matrix[i][j] == 1)//如果第i行j列的元素是1
    			{
    				for (int k = 0;k < line;k++)//开始搜索第j行为1的元素
    				{
    					if (matrix[j][k] == 1)
    					{
    						if (matrix[i][k] != 1)
    							return false;//如果存在这种情况:第i行第j
    //列和第j行第k列的元素均为1,但是第i行第k列的元素不为1,则不具有传递性
    					}
    				}
    			}
    		}
    	}
    	return true;
    }
    bool Ref()
    {
    	for (int i = 0;i < line;i++)
    	{
    		if (matrix[i][i] != 1)
    			return false;//只要主对角线元素存在非1元素,即不具有自反性
    	}
    	return true;
    }
    bool NoRef()
    {
    	for (int i = 0;i < line;i++)
    	{
    		if (matrix[i][i] != 0)//只要对角线存在非0元素,即不具有反自反性
    			return false;
    	}
    	return true;
    }
    bool Sym()
    {
    	for (int i = 0;i < line;i++)
    	{
    		for (int j = 0;j < line;j++)
    		{
    			if (matrix[i][j] != matrix[j][i])
    	//只要第i行第j列元素和第j行第i列元素不相等,即不是对称矩阵,则不具有对称性
    				return false;
    		}
    	}
    	return true;
    }
    bool NoSym()
    {
    	for (int i = 0;i < line;i++)
    	{
    		for (int j = 0;j < line;j++)
    		{
    			if (matrix[i][j] == matrix[j][i] 
    			        && (matrix[i][j] == 1 || matrix[j][i] == 1))
    	//只要存在两个对称位置元素中,存在一个为1,另一个同样为1,则不具有反对称性
    				return false;
    		}
    	}
    	return true;
    }
    

    四、实验分析

    实验要求利用关系矩阵判断五个性质,我们要了解这些性质在关系矩阵的体现是什么。正如源代码中的注释。之后,码代码是很简单的。

    展开全文
  • 二元关系类 成员变量: 指向存储在一维数组中的关系矩阵的指针p; 矩阵的阶数;... 判断关系的特性 //自反,对称,传递  关系的逆; √ 与或位运算;  关系的交并差补; //调用与或位运算 √ 关系的合成;

    二元关系类{

    成员变量:

    指向存储在一维数组中的关系矩阵的指针p;

    矩阵的阶数;     //在构造函数中手动输入

    成员函数:

     重载构造函数(无参数);     //运行时手动输入参数进行初始化

     showMatrix;        //在屏幕上输出矩阵

     判断关系的特性         //自反,对称,传递

    关系的逆;

    与或位运算;

    关系的交并差补;          //调用与或位运算

    关系的合成;             //调用与或位运算(友元函数 * 运算符重载)

    关系的幂;         //循环调用关系的合成函数,并根据P86定理4.3.6进行优化,即判断j次幂是否等于i次幂,等于则循环终止,根据前文推导出较大指数的结果

    关系的自反闭包;              

    关系的对称闭包;

    关系的传递闭包;             //P90 Warshall算法

    };

    打钩的必做,其它选做.

    大概就是这样吧,之前做的面向过程版本,发现做的千疮百孔,所以还是使用类吧.

    貌似给自己挖了个大坑啊,还要撸高数呀哪有时间搞这个...


    update@13.11.25:

    大坑终于终于填上了,基本把之前规划的必做部分完成了,自己也奇怪写了这么多,等我飞起来之后再回头看的时候,也许会感慨自己当年这么挫吧,写的这么拉杂又没效率,嘿嘿.

    //BinaryRelation.h
    
    #pragma once
    #include<iostream>
    using namespace std;
    
    class BinaryRelation
    {
    private:
    	int *p;							//指向存储在一维数组中的关系矩阵
    	int row;								//矩阵的行数
    	int col;								//矩阵的列数
    public:
    	BinaryRelation(void);        //需要手动输入的构造函数
    	BinaryRelation(int row,int col);   //重载构造函数仅建立一个row*col的矩阵
    	const void showMatrix();        //输出二元关系矩阵
    	friend int and(int a,int b);				//与运算
    	friend int or(int a,int b);            //或运算
    	void quality();								//判断关系具有的性质
    	friend BinaryRelation operator *(BinaryRelation& m,BinaryRelation& n);   //关系的合成
    	bool isEqual(BinaryRelation &m);									//判断矩阵是否相等 用于求幂
    	BinaryRelation power(BinaryRelation &m,int n);             //关系的幂
    	BinaryRelation transitiveClosure(BinaryRelation &m);				//关系的传递闭包
    	~BinaryRelation(void);            //析构函数
    };
    

    //BinaryRelation.cpp
    
    #include "BinaryRelation.h"
    #include <vector>
    
    BinaryRelation::BinaryRelation(void)            //构造函数 把手动输入的二元关系初始化为矩阵 
    {
    	int *s = new int[10];
    	int *t = new int[10];
    	char cRow;
    	this->row = 0;
    	this->col = 0;
    	cout<<"Input the set A , end with enter"<<endl;
    	while((cRow = cin.get()) != '\n') 
        { 
            cin.unget(); 
            cin>>s[row];
    		row++;
        } 
    	this->row = this->row-1;
    	char cCol;
    	cout<<"Input the set B , end with enter"<<endl;
    	while((cCol = cin.get()) != '\n') 
        { 
            cin.unget(); 
            cin>>t[col];
    		col++;
        } 
    	this->col = this->col-1;
    	this->p = new int[(row+1)*(col+1)];
    	for(int i = 0; i < (row+1)*(col+1); i++)//初始化矩阵全部为0
    	{
    		this->p[i] = 0;
    	}
    	cout<<"Input binary relation(s), end with enter"<<endl;		//输入集合与序偶建立关系矩阵
    	char end;
    	while((end = cin.get()) != '\n') 
        {
    		cin.unget();
    		int bro1,bro2;
    		int broX = 0;
    		int broY = 0; 
    		cin>>bro1>>bro2;
    		for(int i = 0; i <= row; i++ )
    		{
    			if(s[i] == bro1)
    				broX = i;
    		}
    		for(int j = 0; j <= col; j++)
    		{
    			if(t[j] == bro2)
    				broY = j;
    		}
    		p[broX*(col+1)+broY] = 1;
    	}
    }
    
    BinaryRelation::BinaryRelation(int row,int col)    //重载构造函数:仅建立一个row*col的矩阵
    {
    	this->row = row;
    	this->col = col;
    	this->p = new int[(row+1)*(col+1)];
    	for(int i = 0; i < (row+1)*(col+1); i++)//初始化矩阵全部为0
    	{
    		this->p[i] = 0;
    	}
    }
    
    const void BinaryRelation::showMatrix()							//输出矩阵
    {
    	for(int i = 0;i < this->row+1;i++)	
    	{
    		for(int j = 0;j < this->col+1;j++)
    		{
    			cout<<this->p[i*(col+1)+j]<<" ";
    		}
    		cout<<endl;
    	}
    	cout<<endl;
    }
    
    int and(int a,int b)				//与运算
    {
    	int result;
    	if(0 == a || 0 == b)
    		result = 0;
    	else 
    		result = 1;
    	return result;
    }
    
    int or(int a,int b)			//或运算
    {
    	int result;
    	if(1 == a || 1 == b)
    		result = 1;
    	else
    		result = 0;
    	return result;
    }
    
    void BinaryRelation::quality()											//关系的性质判断
    {
    	bool zifan = 1,fanzifan = 1,duichen = 1,fanduichen = 1,chuandi = 0;
    	for(int i = 0;i <= col;i++)//判断自反and反自反
    	{
    		//cout<<"zifan "<<zifan<<"   fanzifan "<<fanzifan<<endl;
    		if(0 == p[i * (col + 1) + i])
    			zifan = 0;
    		else if(1 == p[i * (col + 1) + i])
    			fanzifan=0;
    	}
    	for(int i = 0;i <= row;i++)//判断对称
    	{
    		for(int j = 0;j <= col;j++)
    		{
    			if(p[i * (col + 1) + j] != p[j * (col + 1) + i])
    				duichen = 0;
    		}
    	}
    	for(int i = 0;i <= row;i++)//判断反对称
    	{
    		for(int j = 0;j <= col;j++)
    		{
    			if(i == j)
    				continue;
    			else if(0 != p[i * (col + 1) + j] * p[j * (col + 1) + i])
    				fanduichen = 0;
    		}
    	}
    	for(int i = 0;i <= row;i++)//判断传递	
    	{
    		for(int j = 0;j <= col;j++)
    		{
    			if(1 == p[i * (col + 1) + j])
    			{
    					for(int l = 0;l <= row;l++)
    					{
    						if(1 == p[i * (col + 1) + j] * p[j * (col + 1) + l])
    						{
    							if(1 != p[i * (col + 1) + l])
    								chuandi = 0;
    						}
    					}
    			}
    			else chuandi = 0;
    		}
    	}
    
    	cout<<"自反   "<<boolalpha<<zifan<<endl;
    	cout<<"反自反 "<<boolalpha<<fanzifan<<endl;
    	cout<<"对称   "<<boolalpha<<duichen<<endl;
    	cout<<"反对称 "<<boolalpha<<fanduichen<<endl;
    	cout<<"传递   "<<boolalpha<<chuandi<<endl;
    }
    
    BinaryRelation operator *(BinaryRelation& m,BinaryRelation& n)				//关系的合成
    {
    	if(m.col == n.row)
    	{
    		BinaryRelation temp(m.row,n.col);
    		for(int i = 0; i < m.row+1; i++)
    		{
    			for(int j = 0; j< n.col+1; j++)
    			{
    				int tempOfAnd = 0;
    				int tempOfOr = 0;
    				for(int k = 0; k < m.col+1; k++)
    				{
    					tempOfAnd = and(m.p[i*(m.col+1)+k],n.p[k*(n.col+1)+j]);
    					//cout<<i<<"*"<<j<<"*"<<k<<"  tempOfAnd: "<<tempOfAnd<<endl;
    					tempOfOr = or(tempOfOr,tempOfAnd);
    					//cout<<i<<"*"<<j<<"*"<<k<<"tempOfOr: "<<tempOfOr<<endl;
    				}
    				temp.p[i*(temp.col+1)+j] = tempOfOr;
    			}
    		}
    		return temp;
    	}
    	else
    	{
    		cout<<"can't composition";
    		return m;
    	}
    }				
    
    bool BinaryRelation::isEqual(BinaryRelation &m)				//判断矩阵是否相等 用于求幂
    {
    	bool isEqual = 1;
    	if(this->row == m.row && this->col == m.col)
    	{
    		for(int i = 0; i < (row+1)*(col+1); i++)
    		{
    			if(this->p[i] != m.p[i])
    				isEqual = 0;
    		}
    	}
    	else
    		isEqual = 0;
    	return isEqual;
    }
    
    BinaryRelation BinaryRelation::power(BinaryRelation &m,int n)					      //关系的幂
    {
    	BinaryRelation temp = m;
    	vector<BinaryRelation> result;		//存储结果
    	int powerMark2;					//	与存储的结果第一次相等的幂指数
    	for(int a = 1; a < n; a++)
    	{
    		int powerMark1 = 1;		//存储的结果中与之后的结果相等的第一个项的幂指数
    		result.push_back(temp);
    		temp = temp * m;
    		for(vector<BinaryRelation>::iterator it = result.begin(); it != result.end();it++)
    		{
    			if(temp.isEqual(*it))
    			{
    				powerMark2 = a + 1;
    				//cout<<"Mark2 "<<powerMark2<<endl;
    				temp = result[((n - powerMark1) % (powerMark2 - powerMark1)) + powerMark1 - 1];
    				/*
    				for(vector<BinaryRelation>::iterator it = result.begin(); it != result.end();it++)
    				{
    					cout<<"输出向量存储内容 当a = "<<a<<"时"<<endl;
    					(*it).showMatrix();
    					cout<<endl;
    				}
    				*/
    				cout<<n<<"次幂 = "<<(((n - powerMark1) % (powerMark2 - powerMark1)) + powerMark1)<<"次幂"<<endl;
    				return temp;
    			}
    			else{
    				powerMark1++;
    			}
    		}
    	}
    	return temp;
    }
    
    BinaryRelation BinaryRelation::transitiveClosure(BinaryRelation &m)								//关系的传递闭包
    {
    	BinaryRelation temp = m;
    	for(int i = 0; i <= temp.row; i++)
    	{
    		for(int j = 0; j <= temp.row; j++)
    		{
    			if(1 == temp.p[j * (col + 1) + i])
    			{
    				for(int k = 0; k <= temp.col; k++)
    				{
    					temp.p[j * (col + 1) + k] =or( temp.p[j * (col + 1) + k] , temp.p[i * (col + 1) + k]);
    				}
    			}
    		}
    	}
    	return temp;
    }
    BinaryRelation::~BinaryRelation(void)					//析构函数
    {
    }					


    最后Main.cpp其实可有可无啦,一起贴上吧

    //main.cpp
    
    #include<iostream>
    #include "BinaryRelation.h"
    using namespace std;
    
    int main()
    {
    	BinaryRelation m;
    	m.showMatrix();
    	m.quality();
    	cout<<endl;
    	cout<<"Input n"<<endl;
    	int n;
    	cin>>n;
    	BinaryRelation power = m.power(m,n);
    	cout<<"m^n:"<<endl;
    	power.showMatrix();
    	BinaryRelation n = (((((m*m)*m)*m)*m)*m);
    	n.showMatrix();
    	BinaryRelation tcM = m.transitiveClosure(m);
    	cout<<"TransitiveClosure:"<<endl;
    	tcM.showMatrix();
    	cout<<endl;
    }


    推荐使用为知笔记(Wiz),它是电脑、手机、平板都能用的云笔记软件,使用我的邀请注册可获VIP体验: http://www.wiz.cn/i/8e5bc961
    展开全文
  • 判断关系性质

    2013-03-08 20:41:52
    离散数学经典实验题,简单的代码,简单的实验
  • 离散数学实验三 关系性质判断

    千次阅读 2020-06-13 22:15:03
    熟悉关系的性质,掌握求判断关系性质的方法 二、实验内容 定义1 设R是集合X上的二元关系,对任意的x∈X,都满足<x,x>∈R,则R是自反的。 定义2 设R是集合X上的二元关系,对任意的x∈X,都满足<x,x>R,则...

    一、实验目的

    熟悉关系的性质,掌握求判断关系性质的方法

    二、实验内容

    定义1 设R是集合X上的二元关系,对任意的x∈X,都满足<x,x>∈R,则R是自反的。
    定义2 设R是集合X上的二元关系,对任意的x∈X,都满足<x,x>R,则R是反自反的。
    定义3 设R是集合X上的二元关系,对任意的x,y∈X,满足<x,y>∈R<y,x>∈R,则R是对称的。
    定义4 设R是集合X上的二元关系,对任意的x,y∈X,满足<x,y>∈R∧<y,x>∈Rx=y,则R是反对称的。X`
    定义5 设R是集合X上的二元关系,对任意的x,y,z∈X,满足<x,y>∈R∧<y,z>∈R<x,z>∈R,则R是传递的。
    本实验要求从键盘输入一个关系的关系矩阵,判断该关系是否是自反的、对称的、传递的、反自反的、反对称的。用C语言或MATLAB实现。
    

    三、实验源程序及结果截图
    1.实验源程序:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main() {
    	int i,j,n;
    	//输入关系矩阵,只能输入0或1,若不是0或1,提示输入错误并结束程序 
    	printf("请输入关系矩阵阶数n:\n");
    	scanf("%d",&n);
    	int a[n][n];
    	printf("请输入关系矩阵真值(0或1):\n");
    	for(i=0;i<n;i++){
    		for(j=0;j<n;j++){
    			scanf("%d",&a[i][j]);
    		}
    	}
    	for(i=0;i<n;i++){
    		for(j=0;j<n;j++){
    			if(a[i][j]!=0&&a[i][j]!=1){
    				printf("输入错误!");
    				return 0;
    			}
    		}
    	}
    	//判断是否为自反矩阵(自反矩阵主对角线元素全为1) 
    	for(i=0;i<n;i++){
    		if(a[i][i]!=1)break; 	
    	}
    	if(i==n)printf("该关系矩阵是自反的\n");
    	else if(i<n)printf("该关系矩阵不是自反的\n");
    	//判断是否为反自反矩阵(反自反矩阵主对角线元素全为0)
    	 for(i=0;i<n;i++){
    		if(a[i][i]!=0)break; 	
    	}
    	if(i==n)printf("该关系矩阵是反自反的\n");
    	else if(i<n)printf("该关系矩阵不是反自反的\n");
    	//判断是否为对称矩阵(对称矩阵a[i][j]==a[j][i])
    	for(i=0;i<n;i++){
    		for(j=0;j<n;j++){
    			if(a[i][j]!=a[j][i])break;			
    		}
    	}
    	if(i>=n&&j>=n)printf("该关系矩阵是对称的\n");
    	else  printf("该关系矩阵不是对称的\n");
    	//判断是否为反对称矩阵(反对称矩阵中i!=j时,a[i][j]和a[j][i]不能同时为1)
    	for(i=0;i<n;i++){
    		for(j=0;j<n;j++){
    			if(i!=j){
    				if(a[i][j]==1&&a[j][i]==1)break;
    			}			
    		}
    	}
    	if(i>=n&&j>=n)printf("该关系矩阵是反对称的\n");
    	else  printf("该关系矩阵不是反对称的\n");
    	//判断是否为传递矩阵(传递矩阵若a[i][j]==1并且a[j][k]==1则a[i][k]一定为1)
    	int k;
    	for(i=0;i<n;i++){
    		for(j=0;j<n;j++){
    			for(k=0;k<n;k++){
    				if(a[i][j]==1&&a[j][k]==1){
    					if(a[i][k]!=1)break;
    				}
    			}
    						
    		}
    	}
    	if(i>=n&&j>=n&&k>=n)printf("该关系矩阵是传递的\n");
    	else  printf("该关系矩阵不是传递的\n");
    	return 0;
    }
    
    展开全文
  • 熟悉关系的性质,掌握求判断关系性质的方法 二、实验内容 定义1 设R是集合X上的二元关系,对任意的x∈X,都满足<x,x>∈R,则R是自反的。 定义2 设R是集合X上的二元关系,对任意的x∈X,都满足<x,x>ÏR...
  • 编程实现关系性质判断 提示: 用矩阵表示二元关系 通过矩阵的特征判断二元关系所具有的性质 运用二维数组实现矩阵的输入 ,然后判断自反性,反自反性,对称性,反对称性,传递性。 思路 自反性,反自反性实现较为...
  • 对离散数学中二元关系的判定及自反、对称、传递闭包的计算
  • 形式逻辑(07)性质判断 推理

    千次阅读 2020-06-17 10:49:16
    性质判断的构成:性质判断是由主项、谓项、联项量项组成。 主项:表示被断定对象的概念,用“S”表示。 谓项:表示被断定对象性质的概念,用“P”表示。 联项:它是联结主项谓项的概念,分为肯定否定两种。...
  • 编程实现关系性质判断实验要求验证原理源代码(c语言)运行结果 作业交了顺便留个档 实验要求 用矩阵表示二元关系 通过矩阵的特征判断二元关系所具有的性质 运用二维数组实现矩阵的输入,然后判断自反性,反自反...
  • 离散实验 //确定矩阵大小,分配空间 void init(char ***a,int *len) { int i,n; printf("集合中有几个元素:"); do { scanf("%d",&n); if(n) printf("n应该大于1\n"); }while(n); ...}
  • /**********关系R的输入,去掉R中的符号***********/ j=0; printf("请输入关系R ( 必须以'}'结束 )\n"); scanf("%s",m); for(i=0;i(m);i++){ if((m[i]!='{')&&(m[i]!=',')&&m[i]!='}'&&m[i]!='...
  • 我尝试着编程实现了课本上集合与关系的相关内容,如集合的逆运算,复合运算,集合上关系性质判断与闭包运算等,基本判断方法均为定义法。 代码如下: #include<iostream> #include<vector> #...
  • 性质判断1) 性质判断:就是断定对象具有或不具有某种属性的判断 (也称为... 联项:也称联结项,它是联结主项谓项的概念,它表示性质判断的“质”,分为肯定否定两种。 一般用“是” “不是”表示。  Ⅳ. 量项:
  • 一、常见的关系性质 、 二、关系性质示例 、 三、关系运算性质
  • 1、关系矩阵的特性判断 判断任意给定一个6×6的关系矩阵是否是自反的、对称的、反对称的,并显示运算结果。 #include using namespace std; int main() { int a[6][6],i; for(i=0;i;i++) { for(int j=0;j...
  • (广东专用)2015高考化学二轮复习 考前三个月 考前专项冲刺集训 第9题 掌握物质的性质和用途 解决因果关系判断
  • 关系性质

    2015-06-06 16:11:57
    已知关系R由关系矩阵M给出,要求判断由M表示的这个关系是否为自反关系、对称关系、传递关系。 算法分析: 1. 若M(R的关系矩阵)的主对角线元素均为1,则R是自反关系;若M(R的关系矩阵)为对称矩阵,则R是对称...
  • c语言程序判断关系R在集合A是否等价、相容、偏序

    千次阅读 多人点赞 2019-11-11 21:51:53
    这是我们离散老师布置的第二次程序作业,...判断关系R在集合A是否等价、相容、偏序,也就是判断关系R是否满足自反,对称,反对称,传递这些性质。 等价:自反,对称,传递 相容:自反,对称 偏序:自反,反对称,传...
  • 判断线的关系

    千次阅读 2012-07-27 11:50:12
    这里判断线的关系要用到矢量乘法 1.矢量叉积  设矢量P = (x1,y1) ,Q = (x2,y2) 则矢量叉积定义为: P × Q = x1*y2 - x2*y1 得到的是一个标量 显然有性质 P × Q = - ( Q × P ) P × ( - Q ) =...
  • 研究二元语义语言判断矩阵的...通过对二元语义评价值与模糊数以及语言评价值的转化关系的研究,论证转化后的二元语义判断矩阵仍然具有一致性等性质,从而保证评价信息的完整性与真实性。最后给出一个航线优选的算例。
  • 离散关系性质报告

    2011-12-29 15:39:54
    刚做的报告,用光标实现操作,内有文件存储读取,然后就是判断一系列的关系了。
  • 利用等价关系性质进行简单的判断!可以以矩阵的方式输入关系的数组。。然后进行判断
  • 目录 自反性与反自反性的判断 对称性与反对称性的判断 传递性的判断 自反性与反自反性的判断 关系R是自反的,当且仅当其关系矩阵的主对角线上元素都为1;关系R是反自反的,当且仅当其关系矩阵的主对角线上元素都为0...
  • 建立表示矩阵的概念,将不确定数互补判断矩阵专家给出的两两比较信息联系起来,表示矩阵即常用的互补判断矩阵。在给出一致性表示矩阵的诸多性质的基础上,给出了求一致性表示矩阵的方法。给出的不确定数互补判断...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,304
精华内容 34,521
关键字:

性质判断和关系判断的区别