离散数学

假设集合A，以及基于A上的关系R
自反：  如果a是A的元素，那么<a,a>是R的元素 ：对角线上的元素是否全为1。全为1则关系是自反关系；
反自反：如果a是A的元素，那么<a,a>不是R的元素显然，整除关系是自反的。要判断是否为反自反关系，同样只需检查关系矩阵上的元素是否全为0值得注意的是，如果集合A非空，则空关系满足反自反，不满足自反系。
但集合A为空集，则空关系满足自反关系，也满足反自反。
从中我们可以看出，关系有可能既是自反关系，又是反自反关系。
同样，关系有可能不是自反关系，也不是反自反关系。

对称：  如果<a,b>是R的元素，那么<b,a>是R的元素主对角线两侧的元素，是否一一对应，保持一致即可
反对称：如果<a,b>，<b,a>是R的元素，那么a,b相等 主对角线两侧的元素，是否一一对应，保持互补（有1的地方，对角线另一侧的位置的元素为0）即可。显然，整除关系是反对称关系

传递：  如果<a,b>，<b,c>是R的元素，那么<a,c>是R的元素
传递关系，在关系矩阵不能一眼直接看出，但是同样可以按照步骤来检查。
方法是：
按从上到下，从左到右，逐一检查某行（例如a行）非对角线上的1元素，
定位到该1元素所在列，所对应的关系矩阵行，
检查该行所有的1元素（或只检查非对角线上的1元素），
将这些1元素所在列的a行元素找出，判断是否都为1
都为1则，是传递关系；
但只要出现1个0，则不是传递关系。
显然，整除关系满足传递性
求传递闭包有一种有效算法—Warshall算法，这种算法也便于计算机实现。 
(1)置新矩阵A＝M； 
(2)i＝1； 
(3)对所有j如果A[j，i]＝1，则对k＝1，2，…，n，A[j，k]＝A[j，k]∨A[i，k](这里的加是布尔加)； 
(4)i加1；（i是行，j是列） 
(5)如果i≤n，则转到步骤3)，否则停止。
#include<bits/stdc++.h>
#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
    bool matrix[100][100];
    int m,n;
    memset(matrix,0,sizeof(matrix));
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        int i,j,k;
        for(i=1;i<=m;i++)
        {
            for(j=1;j<=n;j++)
            {
                scanf("%d",&matrix[i][j]);
            }
        }
        cout<<"..............."<<endl;
        
        for(i=1;i<=m;i++)
        {
            for(j=1;j<=n;j++)
            {
                if (matrix[j][i]==1)
                {
                    for (k=0;k<=n;k++)
                    {
                        matrix[j][k]+=matrix[i][k];
                        continue;
                    }
                }
            }
                for(int a=1;a<=m;a++)
                {
                    for(int b=1;b<=n;b++)
                    {
                        cout<<matrix[a][b]<<" ";
                    }
                cout<<"\n";
                }
            cout<<"........."<<"\n";
        }
 
        cout<<"结果为:"<<"\n";
        for(i=1;i<=m;i++)
        {
            for(j=1;j<=n;j++)
            {
                cout<<matrix[i][j]<<" ";
            }
            cout<<endl;
        }
    }
return 0;
}

#include <stdio.h>
#define N 20
void Init(int r[][N],int c[][N],int n)
{
	int i,j;
	for(i=0;i<n;i++)
	for(j=0;j<n;j++)
	c[i][j]=r[i][j];
}
void print(int c[][N],int n)
{
	int i,j; 
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		printf("%d ",c[i][j]);
		printf("\n");
	}
}
void rr(int r[][N],int n)
{
	int c[N][N];
	int i,j;
	Init(r,c,n);
	for(i=0;i<n;i++)
	c[i][i]=1;
	printf("r的自反闭包:\n");
	print(c,n);
}
void sr(int r[][N],int n)
{
	int c[N][N];
	int i,j;
	Init(r,c,n);
	for(i=0;i<n;i++)
	for(j=0;j<n;j++)
	{
		if(c[i][j]==1)
		{
			c[j][i]=1;
		}
	}
	printf("r的对称闭包:\n");
	print(c,n);
}
void tr(int r[][N],int n)
{
	int b[N][N],c[N][N];
	int i,j,k,m;
	Init(r,c,n);
	for(m=1;m<n;m++)
	{
		for(i=0;i<n;i++)
		for(j=0;j<n;j++)
		{
			b[i][j]=0;
			for(k=0;k<n;k++)
			{
				b[i][j]+=c[i][k]*r[k][j];
			}
			if(b[i][j])
			b[i][j]=1;
		}
		Init(b,c,n);
	}
	printf("r的传递闭包:\n");
	print(c,n);
}
void warshall(int r[][N],int n)
{
	int c[N][N];
	int i,j,k;
	Init(r,c,n);
	for(i=0;i<n;i++)	
	for(j=0;j<n;j++)
		if(c[j][i])
		for(k=0;k<n;k++)
		{
		c[j][k]=c[j][k]+c[i][k];
			if(c[j][k]) 
			c[j][k]=1;
		}
	printf("r的传递闭包:\n");
	print(c,n);
}
int main()
{
	int r[N][N];
	int n;
	int i,j;
	printf("输入n:\n"); 
	scanf("%d",&n);	
	printf("输入矩阵:\n");
	for(i=0;i<n;i++)
	for(j=0;j<n;j++)
	scanf("%d",&r[i][j]);
	rr(r,n);
	sr(r,n);
	warshall(r,n);
	tr(r,n);
	return 0;
}

#include <stdio.h>
#define N 20
void tran(int a[][N],int n)
{
	int i,j,k;
	bool flag=true;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(a[i][j]==0)
			{
				for(k=0;k<n;k++)
				{
					if(a[i][k]!=0&&a[k][j]!=0)
					{
						flag=false;
						break;
					}
				}
			}
			if(!flag)
			break;
		}
		if(!flag)
		break;
	}
	if(flag)
	printf("R为传递关系。\n");
	else
	printf("R为非传递关系。\n");
}
int main()
{
	int n;
	int a[N][N];
	int i,j;
	printf("输入矩阵m的边长:");
	scanf("%d",&n);
	printf("输入矩阵m:\n"); 
	for(i=0;i<n;i++)
	for(j=0;j<n;j++)
	scanf("%d",&a[i][j]); 
	tran(a,n);
	return 0;
}