您的位置：首页 > 其它

【离散数学实验】相容关系的极大相容类的计算

2015-11-18 22:45 267 查看

相容关系的极大相容类的计算.cpp

运行环境VisualStudio2013及以上版本

//=============================================================================

// 离散数学实验（3）_相容关系的极大相容类的计算

// 2015/11/09 ZkP

//=============================================================================

#include<iostream>

#include<vector>

#include<sstream>//基于字符串的流

#include <stdlib.h>

using namespace std;

//=============================================================================

void InputA(vector<int> &A,int &num)

{

cout << "请输入集合A的元素个数num：" << endl;

cin >> num;

cout << "请输入集合A的元素：" << endl;

for (int i = 0; i < num; i++)

A.push_back(getchar());

}

void Inputmat(vector<vector<int>> &mat,int num)

{

cout << "请输入关系矩阵：" << endl;

for (int i = 0; i < num; i++)

for (int j = 0; j < num; j++)

{

vector<int>temp(1);

cin >> temp[0];

mat.push_back(temp);

}

}//Inputmat

//=============================================================================

void DeleteRepeat(vector<vector < int > > &mat)//删除集类中的重复元素

{

int i, j, k, l, m, n, o;

for (i = 0; i < mat.size(); i++)

{

for (j = 0; j < mat[i].size(); j++)

{

for (k = 0; k < mat.size(); k++)

{

for (l = 0; l < mat[k].size(); l++)

{

if (i >= mat.size() || k >= mat.size())

break;

if (i != k&&mat[i][j] == mat[k][l])

{

vector<int> v1(10), v2(10);

v1 = mat[i];

v2 = mat[k];

int count = 0;

for (m = 0; m < v1.size(); m++)

for (n = 0; n < v2.size(); n++)

if (v1[m] == v2
)

{

count++;

break;

}

if (count == v1.size())//若v2是v1的子集

{

for (o = i; o < mat.size() - 1; o++)

mat[o] = mat[o + 1];

mat.pop_back();

}

else if (count == v2.size())//若v1是v2的子集

{

for (o = k; o < mat.size() - 1; o++)

mat[o] = mat[o + 1];

mat.pop_back();

}

}

if (k >= mat.size())

break;

}

}

if (i >= mat.size())

break;

}

}

}//DeleteRepeat

//=============================================================================

void MaximalCompatibleClass(vector<int> A, vector<vector<int>> mat)//求相容类的极大相容类

{

vector< vector< int>> mat1;

int size_A = A.size();

int i, j, k, m;

for (i = 0; i < size_A; i++)//①；

{

vector<int> temp1(1);

temp1[0] = A[i];

mat1.push_back(temp1);

}

for (i = size_A - 2; i > -1; i--)//②③

{

int count = 0;

vector<int> temp2(10);

for (j = size_A - 1; j > i; j--)//④

if (mat[j][i] == 1)

{

temp2[count] = A[j];

count++;

}

if (count != 0)//⑤

{

int size_mat1 = mat1.size();

for (j = 0; j < size_mat1; j++)

{

vector<int> v3(10);

int num = 0;

for (k = 0; k < mat1[j].size(); k++)

for (m = 0; m < count; m++)

if (mat1[j][k] == temp2[m])

{

v3[num] = temp2[m];

num++;

break;

}

if (num != 0)

{

v3[num] = A[i];

while (num < 9)

{

v3.pop_back();

num++;

}

mat1.push_back(v3);

}

}

DeleteRepeat(mat1);//⑥

}

}

cout << "所有极大相容类有：" << endl;

for (i = 0; i < mat1.size(); i++)//输出R中所有的极大相容类

{

cout << "{";

for (j = 0; j < mat1[i].size(); j++)

{

cout << mat1[i][j];

if (j < mat1[i].size() - 1)

cout << ",";

}

cout << "}" << endl;

}

}//MaximalCompatibleClass

//=============================================================================

int Reflexivity(vector<vector<int>> mat)//判断关系R是否具有自反性

{

int r = 1;

for (int i = 0; i < mat.size(); i++)

for (int j = 0; j < mat[i].size(); j++)

if (i == j&&mat[i][j] != 1)

{

r = 0;

return r;

}

return r;

}//Reflexivity

//=============================================================================

int Symmetry(vector<vector<int>> mat)//判断关系R是否具有对称性

{

int s = 1;

for (int i = 0; i < mat.size(); i++)

for (int j = 0; j < mat[i].size(); j++)

if (i != j&&mat[i][j] != mat[j][i])

{

s = 0;

return s;

}

return s;

}//Symmetry

//=============================================================================

void PrintA(vector<int> A)

{

cout << "集合A的元素为：" << endl;

for (int i = 0; i < A.size(); i++)

cout << A[i] << " ";

cout << endl;

}//PrintA

//=============================================================================

void PrintMat(vector<vector<int>> mat)

{

cout << "关系矩阵为：" << endl;

for (int i = 0; i < mat.size(); i++)

{

for (int j = 0; j < mat[i].size(); j++)

cout << mat[i][j] << " ";

cout << endl;

}

}//PrintMat

//=============================================================================

void main()

{

vector<int> A(10);

vector<vector<int>> mat;

int d;

cout << "请输入产生集合A及关系矩阵的方式 1）--键盘输入 2）--系统定义" << endl;

cin >> d;

switch (d)

{

case 1:

{

int num;

InputA(A,num);

Inputmat(mat,num);

}

case 2:

{

A = { 1, 2, 3, 4, 5, 6 };

mat = { { 1, 1, 1, 0, 0, 0 },

{ 1, 1, 1, 1, 1, 0 },

{ 1, 1, 1, 1, 0, 0 },

{ 0, 1, 1, 1, 1, 0 },

{ 0, 1, 0, 1, 1, 0 },

{ 0, 0, 0, 0, 0, 1 } };

}

}//switch

PrintA(A);

cout << endl;

PrintMat(mat);

cout << endl;

if (Reflexivity(mat) && Symmetry(mat))

{

cout << "关系R是集合A上的相容关系！" << endl << endl;;

MaximalCompatibleClass(A, mat);

}

else

cout << "关系R不是集合A上的相容关系！" << endl;

cout << endl;

}//main

//=============================================================================

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航