精华内容
下载资源
问答
  • 内容索引:VC/C++源码,算法相关,离散数学,真值表 不用介绍了吧,离散数学的玩意,求真值表,用C++编程序实现的,可以学习一下哦。
  • C++离散数学算法判断对称矩阵,是一个6*6的矩阵,输入时候可要仔细一点,输入错误的话矩阵就没意义了,VC++写这类矩阵程序,其实也并不复杂哦,判断是否是配对矩阵,其实是很有意思的事。
  • 离散数学集合运算C++或C语言实验报告 离散数学的实验
  • 离散数学实验

    2018-02-02 19:58:40
    离散数学实验,详细描述:http://blog.csdn.net/xunciy/article/details/79242693
  • 已知所给集合 A 和 B,求 A 与 B 的并集 C(C=A∪B)。 使学生更深刻理解集合中并运算定义,并掌握通过计算机语言实现集合并运算的基本方法。 主要仪器设备及耗材 PC,Dev-C++
  • 一、实验目的 使学生更深刻理解集合中交运算定义,并掌握通过计算机语言实现集合交运算的基本方法。 二、实验内容 已知所给集合 A 和 B,求 A 与 B 的交集 C(C=A∩B) 三、主要仪器设备及耗材 PC,Dev-C++
  • C/C++ 离散数学程序实现(总和篇)

    千次阅读 2020-06-16 11:56:23
    一、求两个集合的交集、并集、差集 二、生成包含三个变量和两个逻辑连接词的真值表 三、等价关系判定 四、关系的闭包运算 warshall算法 五、偏序关系上的最大最小极大极小元 六、图中两个顶点的通路数

    目录:
    一、求两个集合的交集、并集、差集
    二、生成包含三个变量和两个逻辑连接词的真值表
    三、等价关系判定
    四、关系的闭包运算 warshall算法
    五、偏序关系上的最大最小极大极小元
    六、图中两个顶点的通路数

    推荐阅读:Python基础自学实用笔记(总和篇)-By Ryan_3610

    1、题目:求两个集合的交集、并集、差集

    1.1代码

    #include <iostream>
    #include <stdio.h>
    #include <string>
    using namespace std;
    //集合的交集、并集运算
    string quchong(string str)          //字符串去重
    {
    	if(str.size()<2)   return str;
    	string tmp_str("\0");
    	tmp_str += str[0];
    	string::size_type j;
    	for(string::size_type i=1 ; i<str.size() ; i++)
    	{
    		for(j=0 ; j<tmp_str.size() ; j++)
    			if(tmp_str[j]==str[i])  break;
    		if(j==tmp_str.size())   tmp_str+=str[i];
    	}
    	return tmp_str;
    }
    //集合的差集、补集运算
    string quziji(string str,string temp)      //字符串去子集
    {
        string result ;
        for (int i = 0; i < str.size(); i++)
        {
            int flag = 0;
            for (int j =0;j < temp.size();j++)
                if (temp[j] == str[i])  flag = 1;
            if (flag == 0)  result += str[i];
        }
        return result;
    }
    
    int main()
    {
        int choice;
        printf("若求交集、并集输入1,若求差集输入2,请输入:");
        cin>>choice;
        string str1,str2,str3;
        char temp[128];
        int len1,len2,num=0,k;
        cout<<"请输入集合1:";
        cin>>str1;
        cout<<"请输入集合2:";
        cin>>str2;
        len1 = str1.length();
        len2 = str2.length();
        str3 = str1 + str2;
    
        for(int i = 0;i < len1; i++)
            for(int j = 0;j < len2 ; j++)
                if(str1[i] == str2[j]) temp[num++]=str1[i];
        temp[num] = '\0';
    
        if(choice == 1) cout<<"两集合交集为:"<<quchong(temp)<<endl;
        if(choice == 1) cout<<"两集合并集为:"<<quchong(str3)<<endl;
        if(choice == 2)
        {
            cout<<"集合1对集合2的差集:"<<quchong(quziji(str1,quchong(temp)))<<endl;
            cout<<"集合2对集合1的差集:"<<quchong(quziji(str2,quchong(temp)))<<endl;
        }
    }
    

    1.2测试

    453fsdf
    Fdg4234

    1.3结果

    在这里插入图片描述
    在这里插入图片描述

    推荐阅读:Python基础自学实用笔记(总和篇)-By Ryan_3610

    2、题目:生成包含三个变量和两个逻辑连接词的真值表

    2.1代码

    #include <iostream>
    #include <stdio.h>
    using namespace std;
    //打印表头
    void printtitle(char a,char b,char c,int one,int two)
    {
    	printf("%c    %c    %c     %c",a,b,c,a);
        switch(one)
    	{
    	    case 0:printf("~%c",b);break;
    		case 1:printf("^%c",b);break;
    		case 2:printf("\\/%c",b);break;
    		case 3:printf("->%c",b);break;
    		case 4:printf("<->%c",b);break;
    	}
    	switch(two)
    	{
    		case 0:printf("~%c\n",c);break;
    		case 1:printf("^%c\n",c);break;
    		case 2:printf("\\/%c\n",c);break;
    		case 3:printf("->%c\n",c);break;
    		case 4:printf("<->%c\n",c);break;
    	}
    }
    //真值运算
    int yunsuan(int p,int q,int connective)
    {
        if(connective==1)
    	{
    		return p*q;
    	}
    	else if(connective==2)
    	{
    		return ((p+q)/2+(p+q)%2);
    	}
    	else if(connective==3)
    	{
    		if(p==0)
    			return 1;
    		else
    		{
    			if(q==1)
    				return 1;
    			else
    				return 0;
    		}
    	}
    	else if(connective==4)
    	{
    		if(p==q)
    			return 1;
    		else
    			return 0;
    	}
    }
    
    int main()
    {
    //输入
        char a,b,c;
        int m,n;
        cout<<"逻辑联结词选择:“非”请输入0,“与”请输入1,“或”请输入2,“蕴涵”请输入3,“双向蕴涵”请输入4!"<<endl;
        cout<<"输入第1个变量:";         cin>>a;
        cout<<"输入第一个逻辑连接词:";  cin>>m;
        cout<<"输入第2个变量:";         cin>>b;
        cout<<"输入第二个逻辑连接词:";  cin>>n;
        cout<<"输入第3个变量:";         cin>>c;
    //输出表头
        printtitle(a,b,c,m,n);
    //输出格式及运算结果
        int i,j,k;
        for (i=0;i<2;i++)
        {
            for (j=0;j<2;j++)
            {
                for (k=0;k<2;k++)
                {
                    printf("%d    %d    %d      ",i,j,k);
                    if(m<=n) cout<<yunsuan(yunsuan(i,j,m),k,n)<<endl;
                    else cout<<yunsuan(i,yunsuan(j,k,n),m)<<endl;
                }
            }
        }
    return 0;
    }
    

    2.2测试

    a
    1
    b
    4
    c

    2.3结果

    在这里插入图片描述

    推荐阅读:Python基础自学实用笔记(总和篇)-By Ryan_3610

    3、题目:等价关系判定

    3.1代码

    #include <iostream>
    #include <stdio.h>
    using namespace std;
    //等价关系:满足自反对称传递
    int main()
    {
    //输入
        int n,num[20][20];
        cout<<"请输入该关系矩阵阶数:";
        cin>>n;
        for (int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                cin>>num[i][j];
        }
    //自反判断
        for(int i = 0;i<n;i++)
        {
            if(num[i][i] != 1)
            {
                cout<<"非等价关系"<<endl;
                return 0;
            }
        }
    //对称判断
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            {
                if (i != j)
                {
                    if(num[i][j] != num[j][i])
                    {
                        cout<<"非等价关系"<<endl;
                        return 0;
                    }
                }
            }
    //可传递判断(算法)
        int num0[20][20];
        //矩阵相乘
        int temp=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                temp = 0;
                for (int m=0;m<n;m++)
                    temp += num[i][m]*num[m][j];
                num0[i][j] = temp;
            }
        }
    
        //子集判断
        for (int i = 0; i < n; i++)
    	{
    		for (int j = 0; j < n; j++)
    		{
    			if (num[i][j] == 0)
    			{
    				if (num0[i][j] != 0)
    				{
    					cout << "非等价关系"<<endl;
    					return 0;
    				}
    			}
    		}
    	}
    //最后结果
        cout<<"是等价关系"<<endl;
        return 0;
    }
    
    

    3.2测试

    5
    1 1 0 0 0
    1 1 1 0 1
    0 1 1 1 0
    0 0 1 1 1
    0 1 0 1 1

    5
    1 0 0 0 0
    0 1 0 0 0
    0 0 1 0 0
    0 0 0 1 0
    0 0 0 0 1

    3.3结果

    在这里插入图片描述
    在这里插入图片描述

    推荐阅读:Python基础自学实用笔记(总和篇)-By Ryan_3610

    4、题目:关系的闭包运算 warshall算法

    4.1代码

    #include <iostream>
    #include <stdio.h>
    using namespace std;
    
    int main()
    {
    //输入
        int n=0,num[20][20];
        char name[20];
        cout<<"请输入元素个数:";
        cin>>n;
        cout<<"请输入关系矩阵:\n";
        for (int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                cin>>num[i][j];
        }
    
    //warshall算法
        for (int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(num[j][i])
                    for (int m=0;m<n;m++)
                        num[j][m] = num[j][m] + num[i][m];
            }
        }
    //输出
        cout<<"----------传递闭包关系矩阵----------\n";
        for (int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(num[i][j] > 1)
                    num[i][j] = 1;
                cout<<num[i][j]<<" ";
            }
            cout<<endl;
        }
        return 0;
    }
    
    

    4.2测试

    4
    0 1 0 0
    1 0 1 0
    0 0 0 1
    1 0 1 1

    4.3结果

    在这里插入图片描述

    推荐阅读:Python基础自学实用笔记(总和篇)-By Ryan_3610

    5、题目:偏序关系上的最大最小极大极小元

    5.1代码

    #include <iostream>
    #include <stdio.h>
    using namespace std;
    //偏序关系上的最大最小极大极小元
    //判断除主对角线上的数
    int main()
    {
        int n,num[20][20];
        cout<<"请输入集合中元素个数:";
        cin>>n;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                cin>>num[i][j];
        }
    //最大元判定(列全1)
        int flag=0;
        cout<<"最大元为:";
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if (i!=j)
                {
                    if(num[j][i] == 0)
                        flag = 1;
                }
            }
            if (flag == 0)
            {
                cout<<i+1<<" ";
            }
            flag = 0;
        }
        cout<<endl;
    //极大元判定(行全0)
        cout<<"极大元为:";
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if (i!=j)
                {
                    if(num[i][j] == 1)
                        flag = 1;
                }
            }
            if (flag == 0)
            {
                cout<<i+1<<" ";
            }
            flag = 0;
    
        }
        cout<<endl;
    //最小元判定(行全1)
        cout<<"最小元为:";
       for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if (i!=j)
                {
                    if(num[i][j] == 0)
                        flag = 1;
                }
            }
            if (flag == 0)
            {
                cout<<i+1<<" ";
            }
            flag = 0;
        }
        cout<<endl;
    //极小元判定(列全0)
        cout<<"极小元为:";
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if (i!=j)
                {
                    if(num[j][i] == 1)
                        flag = 1;
                }
            }
            if (flag == 0)
            {
                cout<<i+1<<" ";
            }
            flag = 0;
        }
        cout<<endl;
    }
    
    

    5.2测试

    6
    1 1 1 0 1 1
    0 1 0 0 0 1
    0 0 1 0 1 1
    0 0 0 1 0 1
    0 0 0 0 1 1
    0 0 0 0 0 1

    5.3结果

    在这里插入图片描述

    推荐阅读:Python基础自学实用笔记(总和篇)-By Ryan_3610

    6、题目:图中两个顶点的通路数

    6.1代码

    #include <iostream>
    #include <stdio.h>
    using namespace std;
    int main()
    {
    //输入
        int n;
        int num1[10][10]={0};
        int num[10][10];
        cin>>n;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                cin>>num[i][j];
            }
        }
    //矩阵乘法
        int temp=0;
        for(int k=0;k<n-1;k++)        //k阶
        {
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    temp = 0;
                    for (int m=0;m<n;m++)
                        temp += num[i][m]*num[m][j];
                    num1[i][j] = temp;
                }
            }
        }
    //输出答案
        printf("----------------------------------\n");
        int sum=0;
        int x,y;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                cout<<num1[i][j]<<" ";
            }
            printf("\n");
        }
    
        cout<<"输入起始点:";
        cin>>x>>y;
        cout<<num1[x-1][y-1];
    }
    
    

    6.2测试

    4
    1 2 3 4
    1 2 3 4
    1 2 3 4
    1 2 3 4

    6.3结果

    在这里插入图片描述

    展开全文
  • C++ 图论 离散数学

    2014-03-30 22:50:23
    以偶对的形式输入一个无向简单图的边,建立该图的邻接矩阵,判断图是否连通(A)。并计算任意两个结点间的距离(B)。对不连通的图输出其各个连通支(C)。
  • 离散数学 关系运算(c++

    千次阅读 2020-12-10 09:24:06
    离散数学 关系运算代码(c++) 包含以下功能: 1.求有限集上给定关系的自反闭包、对称闭包、传递闭包。 2.求有限集上等价关系的数目。 3.输入集合和等价关系,求对应的商集。 4.判断是否为等价关系。 Relation.h #...

    离散数学 关系运算代码(c++)

    包含以下功能:
    1.求有限集上给定关系的自反闭包、对称闭包、传递闭包。
    2.求有限集上等价关系的数目。
    3.输入集合和等价关系,求对应的商集。
    4.判断是否为等价关系。

    Relation.h

    #ifndef RELATION_H_INCLUDED
    #define RELATION_H_INCLUDED
    #include<string.h>
    using namespace std;
    struct Relation
    {
        bool **Mat;  //存放关系矩矩阵
        string *Arr;  //存放元素集合
        int n;  //存放元素个数
    };
    void InitRelation(Relation &R,int n)  //初始化关系矩阵
    {
        R.n=n;
        R.Arr=new string[n];
        R.Mat=new bool *[n];
        for(int j=0;j<n;j++)
        {
           R.Mat[j]=new bool[n];
           for(int k=0;k<n;k++)
            R.Mat[j][k]=false;
        }
    }
    void Show(Relation R)  //输出关系矩阵
    {
        cout<<'{';
        for(int i=0;i<R.n-1;i++)
            cout<<R.Arr[i]<<", ";
        cout<<R.Arr[R.n-1]<<'}'<<endl;
        for(int i=0;i<R.n;i++)
        {
            for(int j=0;j<R.n;j++)
                cout<<R.Mat[i][j];
            cout<<endl;
        }
    }
    int Locate(Relation R,string str) //寻找目标元素在集合中的位置
    {
        for(int i=0;i<R.n;i++)
        {
            if(str==R.Arr[i])
                return i;
        }
        return -1;
    }
    void CreateRelation(Relation &R) //输入关系
    {
        string a,b;
        cout<<"请输入各元素"<<endl;
        for(int i=0;i<R.n;i++)
            cin>>R.Arr[i];
        cout<<"请给定各元素之间关系,以# #结束"<<endl;
        cin>>a>>b;
        while(a!="#"||b!="#")
        {
            int i,j;
            i=Locate(R,a);
            j=Locate(R,b);
            if(i<0||j<0)
                cout<<"元素不合法,请检查!"<<endl;
            else
                R.Mat[i][j]=true;
            cin>>a>>b;
        }
    
    }
    Relation ReflexiveClosure(Relation &R)   //求自反闭包
    {
        Relation S;
        InitRelation(S,R.n);
        for(int i=0;i<R.n;i++)
        {
            S.Arr[i]=R.Arr[i];
            for(int j=0;j<R.n;j++)
                S.Mat[i][j]=R.Mat[i][j];
        }
        for(int i=0;i<S.n;i++)
            S.Mat[i][i]=true;
        return S;
    }
    Relation SymmetricClosure(Relation &R)  //求对称闭包
    {
        Relation S;
        InitRelation(S,R.n);
        for(int i=0;i<R.n;i++)
        {
            S.Arr[i]=R.Arr[i];
            for(int j=0;j<R.n;j++)
                S.Mat[i][j]=R.Mat[i][j];
        }
        for(int i=0;i<S.n;i++)
        {
            for(int j=i;j<S.n;j++)
            {
                if(S.Mat[i][j]==true)
                    S.Mat[j][i]=true;
            }
        }
        return S;
    }
    Relation TransitiveClosure(Relation &R)  //求传递闭包
    {
        Relation S;
        InitRelation(S,R.n);
        for(int i=0;i<R.n;i++)
        {
            S.Arr[i]=R.Arr[i];
            for(int j=0;j<R.n;j++)
                S.Mat[i][j]=R.Mat[i][j];
        }
        for(int i=0;i<S.n;i++)
        {
            for(int j=0;j<S.n;j++)
            {
                if(S.Mat[i][j]==true)
                {
                    for(int k=0;k<S.n;k++)
                    {
                        if(S.Mat[j][k]==true)
                            S.Mat[i][k]=true;
                    }
                }
            }
        }
        return S;
    }
    int NumOfEquivalent(int n)  //求等价关系数
    {
        int a[n+1][n+1];
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            a[1][i]=1;
            a[i][i]=1;
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
                a[i][j]=a[i-1][j-1]+i*a[i][j-1];
        }
       for(int i=1;i<=n;i++)
        sum+=a[i][n];
        return sum;
    }
    bool isReflexive(Relation R)  //验证自反性
    {
        for(int i=0;i<R.n;i++)
        {
            if(R.Mat[i][i]!=true)
                return  false;
        }
        return true;
    }
    bool isSymmetric(Relation R)  //验证对称性
    {
        for(int i=0;i<R.n;i++)
        {
            for(int j=i+1;i<R.n;j++)
            {
                if(R.Mat[i][j]!=R.Mat[j][i])
                return false;
            }
        }
        return true;
    }
    bool isTreansitive(Relation R)  //验证传递性
    {
        for(int i=0;i<R.n;i++)
        {
            for(int j=0;j<R.n;j++)
            {
                if(R.Mat[i][j]==1)
                {
                    for(int k=0;k<R.n;k++)
                    {
                        if((R.Mat[j][k]==1&&R.Mat[i][k]==1)==false)
                            return false;
                    }
                }
            }
        }
        return true;
    }
    
    void QuotientSet(Relation R)  //根据集合与关系求商集
    {
        bool visited[R.n];
        for(int i=0;i<R.n;i++)
            visited[i]=false;
        if(isReflexive(R)==false&&isSymmetric(R)==false&&isTreansitive(R)==false)
        {
            cout<<"您输入的不是等价关系!"<<endl;
            return;
        }
        else
        {
            cout<<"商集为: "<<"{";
            for(int i=0;i<R.n;i++)
            {
                if(visited[i]==false)
                {
                    visited[i]=true;
                cout<<"{";
                cout<<R.Arr[i];
                for(int j=0;j<R.n;j++)
                {
                    if(R.Mat[i][j]==1&&visited[j]==false)
                    {
                        visited[j]=true;
                        cout<<","<<R.Arr[j];
                    }
                }
                cout<<"}";
                }
            }
            cout<<"}";
        }
    }
    #endif // RELATION_H_INCLUDED
    
    

    Main.cpp

    #include <iostream>
    #include "Relation.h"
    using namespace std;
    
    int main()
    {
        Relation A;
        cout<<"请输入元素个数"<<endl;
        int n;
        cin>>n;
        InitRelation(A,n);
        cout<<"该集合有"<<NumOfEquivalent(n)<<"种等价关系"<<endl;
        CreateRelation(A);
        Show(A);
        Show(TransitiveClosure(A));
        Show(ReflexiveClosure(A));
        Show(SymmetricClosure(A));
        QuotientSet(A);
    }
    
    
    展开全文
  • 我尝试着编程实现了课本上集合与关系的相关内容,如集合的逆运算,复合运算,集合上关系的性质判断与闭包运算等,基本判断方法均为定义法。 代码如下: #include<iostream> #include<...

    我尝试着编程实现了课本上集合与关系的相关内容,如集合的逆运算,复合运算,集合上关系的性质判断与闭包运算等,基本判断方法均为定义法

    代码如下:

    #include<iostream>
    #include<vector>
    #include<algorithm>
    using namespace std;
    typedef vector<vector<int>> v_v;
    
    void PrintMatrix(const v_v& v)   //打印矩阵
    {
    	for (auto &i : v)
    	{
    		for (auto j : i)
    			cout << j << " ";
    		cout << endl;
    	}
    }
    
    void Get_Matrix(v_v& v,int num)    //得关系矩阵
    {
    	vector<int> A, B;
    	int a, b, n;
    	if (num == 1)
    	{
    		cout << "请输入前域的元素个数及各元素" << endl;
    		cin >> n;
    		v.resize(n);     //初始化v的大小
    		while (n--)
    		{
    			cin >> a;
    			A.push_back(a);
    		}
    		cout << "请输入陪域的元素个数及各元素" << endl;
    		cin >> n;
    		for (int i = 0; i != v.size(); ++i)
    			v[i].resize(n);
    		while (n--)
    		{
    			cin >> b;
    			B.push_back(b);
    		}
    	}
    	else if (num == 2)
    	{
    		cout << "请输入集合的元素个数及各元素" << endl;
    		cin >> n;
    		v.resize(n);
    		for (int i = 0; i != v.size(); ++i)
    			v[i].resize(n);
    		while (n--)
    		{
    			cin >> a;
    			A.push_back(a);
    		}
    		B = A;
    	}
    	cout << "请输入关系中元素个数及各个序偶" << endl;
    	cin >> n;
    	while (n--)
    	{
    		cin >> a >> b;
    		auto a_loc = find(A.begin(), A.end(), a);
    		auto b_loc = find(B.begin(), B.end(), b);
    		int a_index = distance(A.begin(), a_loc);      //得a,b下标 
    		int b_index = distance(B.begin(), b_loc);
    		v[a_index][b_index] = 1;
    	}
    	cout << "其关系矩阵:" << endl;
    	PrintMatrix(v);
    }
    
    v_v MatrixInver(const v_v& v)     //关系逆运算
    {
    	int row = v.size();
    	int col = v[0].size();
    	v_v v_inv(col);
    	for (int i = 0; i != col; ++i)
    		v_inv[i].resize(row);
    	for (int i = 0; i != row; ++i)
    		for (int j = 0; j != col; ++j)
    			v_inv[j][i] = v[i][j];
    	return v_inv;
    }
    
    v_v MatrixMul(const v_v& v1, const v_v& v2)   //关系复合运算
    {
    	v_v v_mul;
    	int m = v1.size(), n = v2.size(), p = v2[0].size();
    	v_mul.resize(m);
    	for (int i = 0; i != m; ++i)
    		v_mul[i].resize(p);
    	for (int i = 0; i != m; ++i)
    		for (int j = 0; j != p; ++j)
    			for (int k = 0; k != n; ++k)
    				v_mul[i][j] |= v1[i][k] * v2[k][j];
    	return v_mul;
    }
    
    void Reflex(const v_v& v)
    {
    	int count = 0;
    	v_v v1(v);
    	for (int i = 0; i != v.size(); ++i)
    		if (v[i][i] == 1)
    			++count;
    	if (count == v.size())
    		cout << "该关系具有自反性" << endl;
    	if (count == 0)
    		cout << "该关系具有反自反性" << endl;
    	cout << "其自反闭包的关系矩阵为" << endl;
    	for (int i = 0; i != v.size(); ++i)
    		v1[i][i] = 1;
    	PrintMatrix(v1);
    }
    
    void Symmetry(const v_v& v)
    {
    	v_v v1(v);
    	bool flag1 = true, flag2 = true;
    	for (int i = 0; i != v.size(); ++i)
    	{
    		for (int j = 0; j != v.size(); ++j)
    		{
    			if (i != j)
    			{
    				if (v[i][j] != v[j][i])
    					flag1 = false;
    				else
    					flag2 = false;
    			}
    		}
    	}
    	if (flag1)
    		cout << "该关系具有对称性" << endl;
    	if(flag2)
    		cout << "该关系具有反对称性" << endl;
    	cout << "其对称闭包的关系矩阵为" << endl;
    	auto inver = MatrixInver(v);
    	for (int i = 0; i != v.size(); ++i)
    	{
    		for (int j = 0; j != v.size(); ++j)
    		{
    			v1[i][j] |= inver[i][j];
    		}
    	}
    	PrintMatrix(v1);
    }
    
    void Trans(const v_v& v)
    {
    	v_v v1(v);
    	bool flag = true;
    	for (int i = 0; i != v.size(); ++i)              //Warshall算法求传递闭包
    	{
    		for (int j = 0; j != v.size(); ++j)
    		{
    			if (v[i][j])
    			{
    				for (int k = 0; k != v.size(); ++k)
    				{
    					if (v[j][k])
    						if (v[i][k] == 0)
    							flag = false;
    				}
    			}
    		}
    	}
    	if (flag)
    		cout << "该关系具有传递性" << endl;
    	cout << "其传递闭包的关系矩阵为" << endl;
    	for (int i = 0; i != v.size(); ++i)
    	{
    		for (int j = 0; j != v.size(); ++j)
    		{
    			if (v[j][i])
    				for (int k = 0; k != v.size(); ++k)
    					v1[j][k] |= v[i][k];
    		}
    	}
    	PrintMatrix(v1);
    }
    
    int main()
    {
    	int next;
    	v_v v1, v2, v_mul;
    	cout << "1、集合间的关系运算\t2、集合上的关系性质判断及闭包运算" << endl;
    	cin >> next;
    	if (next == 1)
    	{
    		Get_Matrix(v1,1);
    		cout << "关系运算:1、逆运算\t2、复合运算" << endl;
    		cin >> next;
    		if (next == 1)
    		{
    			cout << "其结果为" << endl;
    			PrintMatrix(MatrixInver(v1));
    		}
    		else if (next == 2)
    		{
    			cout << "现请输入另一矩阵相关数据" << endl;
    			Get_Matrix(v2,1);
    			cout << "其结果为" << endl;
    			PrintMatrix(MatrixMul(v1, v2));
    		}
    	}
    	else if (next == 2)
    	{
    		Get_Matrix(v1,2);
    		cout << endl;
    		Reflex(v1);
    		cout << endl;
    		Symmetry(v1);
    		cout << endl;
    		Trans(v1);
    		cout << endl;
    	}
    	system("pause");
    }

     

    展开全文
  • c++离散数学】由合式公式生成多层真值表
  • c++程序判断离散数学中命题公式
  • C++文件: //定义: !为非 &为合取 |为析取 >为条件 -为双条件 #include"TrueTable.h" int main() { TruthTable formula; cout 请输入命题公式(命题变元是大写字母)" ; cout 注:定义:!为非 &为合取 |...

    思路参考:https://blog.csdn.net/wjh2622075127/article/details/79843339 感谢作者。

    试着写了一下头文件,并修改优化了。

    头文件:

    #ifndef TRUTH_TABLE_H
    #define TRUTH_TABLE_H
    #include<iostream>
    #include<string>
    #include<iomanip>
    #include<cmath>
    #include<algorithm>
    using namespace std;
    class TruthTable
    {
    	friend void read(istream& is, TruthTable& formula);    //读取输入
    	friend void print(TruthTable& formula);        //计算并输出
    public:
    	void GetVariable(string str, string& var, int& count);    //获取命题变元
    	void fei(string& str);                //非
    	void hequ(string& str);               //合取
    	void xiqu(string& str);              //析取
    	void tiaojian(string& str);            //条件
    	void shuangtiaojian(string& str);         //双条件
    	void ToValue(string& str, int val[]);    //赋真值给 变元
    	void DelKuohao(string& str);         //去除无用的括号(括号内只有一个变元的情况)
    private:
    	string str, tmp, var;
    	int count = 0;
    	int val[30]{};
    };
    void TruthTable::GetVariable(string str, string& var, int& count)
    {
    	int ch[30]{};
    	for (auto i = 0; i != str.size(); ++i)
    		if (isalpha(str[i]))
    			++ch[str[i] - 'A'];
    	for (auto i = 0; i < 26; ++i)
    		if (ch[i])
    		{
    			var.push_back(i + 65);
    			++count;
    		}
    }
    void TruthTable::fei(string& str)
    {
    	for (auto i = 0;i!=str.size();++i)
    	{
    		if (i + 1 < str.size() && str[i] == '!' && str[i + 1] == '0')
    			str.replace(i, 2 , "1");
    		else if ( i + 1 < str.size() && str[i] == '!' && str[i + 1] == '1')
    			str.replace(i, 2, "0");
    	}
    }
    void TruthTable::hequ(string& str)
    {
    	for (auto i = 0;i!=str.size();++i)
    	{
    		if (str[i] == '1' && i + 2 < str.size() && str[i + 2] == '1' && str[i + 1] == '&')
    			str.replace(i, 3 , "1");
    		else if (i + 2 < str.size() && str[i + 1] == '&' && ((str[i] == '1' && str[i + 2] == '0')
    			|| (str[i] == '0' && str[i + 2] == '1') || (str[i] == '0' && str[i + 2] == '0')))
    			str.replace(i, 3, "0");
    	}
    }
    void TruthTable::xiqu(string& str)
    {
    	for (auto i = 0; i != str.size(); ++i)
    	{
    		if (str[i] == '0' && i + 2 < str.size() && str[i + 2] == '0' && str[i + 1] == '|')
    			str.replace(i, 3, "0");
    		else if (i + 2 < str.size() && str[i + 1] == '|' && ((str[i] == '1' && str[i + 2] == '0')
    			|| (str[i] == '0' && str[i + 2] == '1') || (str[i] == '1' && str[i + 2] == '1')))
    			str.replace(i, 3, "1");
    	}
    }
    void TruthTable::tiaojian(string& str)
    {
    	for (auto i = 0; i != str.size(); ++i)
    	{
    		if (str[i + 1] == '>' && str[i] == '1' && str[i + 2] == '0')
    			str.replace(i, 3, "0");
    		else if (str[i + 1] == '>' && ((str[i] == '1' && str[i + 2] == '1')
    			|| str[i] == '0' && (str[i + 2] == '1' || str[i + 2] == '0')))
    			str.replace(i, 3, "1");
    	}
    }
    void TruthTable::shuangtiaojian(string& str)
    {
    	for (auto i = 0; i != str.size(); ++i)
    	{
    		if (str[i + 1] == '-' && ((str[i] == '1' && str[i + 2] == '1') || (str[i] == '0' && str[i + 2] == '0')))
    			str.replace(i, 3, "1");
    		else if (str[i + 1] == '-' && ((str[i] == '1' && str[i + 2] == '0') || (str[i] == '0' && str[i + 2] == '1')))
    			str.replace(i, 3, "0");
    	}
    }
    void TruthTable::ToValue(string& str, int val[])
    {
    	for (auto i = 0; i != str.size(); ++i)
    	{
    		if (isalpha(str[i]))
    			str.replace(i, 1, val[str[i] - 'A'] ? "1" : "0");
    	}
    }
    void TruthTable::DelKuohao(string& str)
    {
    	for (auto i = 0; i != str.size(); ++i)
    	{
    		if (str[i] == '(' && i + 2 < str.size() && str[i + 2] == ')')
    		{
    			string s;
    			s += str[i + 1];
    			str.replace(i, 3, s);
    		}
    	}
    }
    void read(istream& is, TruthTable& formula)
    {
    	is >> formula.str;
    	transform(formula.str.begin(), formula.str.end(), formula.str.begin(), ::toupper);
    	formula.tmp = formula.str;
    	formula.GetVariable(formula.str, formula.var, formula.count);
    }
    
    void print(TruthTable& formula)
    {
    	for (auto i : formula.var)           //输出真值表格式第一行
    		cout << i << "  ";
    	cout << formula.str << endl;
    	for (int i = 0; i != pow(2, formula.count); ++i)      //二进制枚举法
    	{
    		for (int j = 0; j != formula.count; ++j)
    			formula.val[formula.var[j] - 'A'] = (1 & (i >> (formula.count - 1 - j)));    //位运算赋值
    		for (int j = 0; j != formula.count; ++j)
    			cout << formula.val[formula.var[j] - 'A'] << "  ";
    		formula.ToValue(formula.str, formula.val);
    		while (formula.str.size() != 1)
    		{
    			formula.DelKuohao(formula.str);
    			formula.fei(formula.str);
    			formula.hequ(formula.str);
    			formula.xiqu(formula.str);
    			formula.tiaojian(formula.str);
    			formula.shuangtiaojian(formula.str);
    		}
    		cout << setw(formula.tmp.size() / 2 + 1) << formula.str << endl;
    		formula.str = formula.tmp;
    	}
    }
    #endif // !TRUTH_TABLE

    C++文件:

     //定义: !为非  &为合取 |为析取 >为条件  -为双条件
    #include"TrueTable.h"
    int main()
    {
    	TruthTable formula;
    	cout << "请输入命题公式(命题变元是大写字母)" << endl;
    	cout << "注:定义:!为非  &为合取 |为析取 >为条件  -为双条件" << endl;
    	read(cin, formula);
    	print(formula);
    	system("pause");
    }

     

    展开全文
  • 离散数学_C++生成真值表_模拟

    千次阅读 多人点赞 2018-04-07 17:34:59
    生成真值表的代码 输入一个真值表达式, 程序自动生成它的真值表. 纯模拟思路 合取* 析取| 单条件&gt; 双条件- 非! #include &lt;iostream&gt;...int cnt = 0, chval...
  • 离散数学实验-C++实现集合关系判定

    千次阅读 2020-06-14 09:16:23
    大一代码-离散数学集合有关关系的判断1. 程序的设计思路2. 编程调试过程中遇到的问题及其解决过程3.程序代码4总结(心得体会)5.参考资料 1. 程序的设计思路 1.求传递闭包:对于任意顶点i和j,若两顶点连通但非邻接点...
  • 用C\C++实现离散数学简单逻辑运算

    千次阅读 2015-05-09 18:52:20
    这两天写C语言代码遇到这个离散题,感觉还是蛮经典的,自己总结一下。 编写程序,解决下述问题:已知有A、B、 C、D、E、F共6人参加程序竞赛。其中:  A和B中至少一人获奖;  A、C、D中至少二人获奖;  A、E...
  • 内容索引:VC/C++源码,算法相关,离散数学 用C++实现离散数学中的求集合这一公式,原理及代码都很简单的问题。
  • //1.3 交集 #include<stdio.h> #include<string.h> #define MAX 100 //降序 void sortstring( char s[],int n ) { int i,j,k; char temp; for( i=0;i<n-1;i++ ){ k=i;... te.
  • //自反判断函数 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) ...}
  • 真值表的C++实现 离散数学课程设计论文
  • ![图片说明](https://img-ask.csdn.net/upload/202002/21/1582265514_56643.png) 该关系是否具有反对称性?
  • 用C语言实现离散数学中的任意合式公式的真值表
  • c++程序判断离散数学中命题公式,MFC开发
  • 离散数学】编程练习:消解算法

    千次阅读 2019-12-26 09:11:00
    实现功能:消解算法 输入:合式公式 A 的合取范式 输出:当 A 是可满足时,回答“YES ”;否则回答“NO”。 #include <stdio.h> #include <string.h> #define N 50 ...void convert_form(cha...
  • 完整地图涂色的实现,用C++,离散数学作业!
  • 实验一 命题逻辑运算器 实验二 集合运算 实验三 关系的性质 实验四 欧拉图的判定
  • 实验内容: 对具有n个结点的无向图,判断其能否被一笔画。 实验要求: 对给定n个结点的无向图,进行欧拉图和半欧拉图的判定,若是欧拉图或半欧拉图,则输出所有的欧拉(回)路。
  • 内容索引:VC/C++源码,算法相关,离散数学,矩阵 6行6列的矩阵,闲来无事,用VC++写一个小程序,判断是否是配对矩阵,很有意思哦!
  • 为了解决离散数学的最短路径问题,使用DJ斯特拉算法解决此问题。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,825
精华内容 5,930
关键字:

c++离散数学

c++ 订阅