关闭

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

1500人阅读 评论(0) 收藏 举报
分类:



相容关系的极大相容类的计算.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[n])
        {
         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
//=============================================================================




11
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:105876次
    • 积分:2728
    • 等级:
    • 排名:第13276名
    • 原创:103篇
    • 转载:12篇
    • 译文:0篇
    • 评论:32条
    博客专栏
    最新评论