离散数学实验。等价关系

实现功能：集合A上的二元关系R同时具有自反性、对称性和传递性，则称R是A上的等价关系。给定非空集合A上二元关系R的关系矩阵，判断R是否是A上的等价关系。

输入：一次输入一个关系矩阵，每一行两个相邻元素之间用一个空格隔开，输入元素的行与列分别对应关系矩阵的行与列。注：关系的基数小于12。

输出：1.Y/N（注：具备自反性为Y，不具备为N）

       2.Y/N（注：具备对称性为Y，不具备为N）

       3.Y/N（注：具备传递性为Y，不具备为N）

       4.Y/N（注：是等价关系为Y，无等价关系为N）

离散数学的应用（C语言实现）
非常详细
可以参考下
https://blog.csdn.net/qq_60545192/article/details/128860324

上图

代码

#include <iostream> 
using namespace std;

const int N = 12; // 最多12个元素

int relation[N][N];

// 判断自反性 
bool isReflexive() {
    for (int i = 0; i < N; i++) {
        if (relation[i][i] == 0) return false;       
    }      
    return true;
}

// 判断对称性
bool isSymmetric() {
   for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
         if (relation[i][j] != relation[j][i])  
             return false;
      }
   }
   return true;
}

// 判断传递性 
bool isTransitive() {
    for (int i = 0; i < N; i++) { 
       for (int j = 0; j < N; j++) {
           for (int k = 0; k < N; k++) {
               if (relation[i][j] == 1 && relation[j][k] ==1 && relation[i][k] ==0)
                  return false;
           }
       }       
    }
   return true;     
}

int main() {
   // 输入关系矩阵
   // ... 
   cout << isReflexive() << endl;  
   cout << isSymmetric() << endl; 
   cout << isTransitive() << endl;
        
   if (isReflexive() && isSymmetric() && isTransitive()) {
      cout << "Y" << endl;  
   } else {
      cout << "N" << endl;
   } 
}

c语言实现的，给定非空集合A上二元关系R的关系矩阵，判断R是否是A上的等价关系代码，帮你找到一位博主的代码，跟你的需求完全一致，提供了完整的代码，可以直接参考：
C语言实现离散数学二元关系及其性质：https://blog.csdn.net/m0_55986434/article/details/122856310

C++示例

#include <iostream>
#include <vector>

using namespace std;

// 判断关系矩阵是否是等价关系
string checkEquivalenceRelation(const vector<vector<int>>& matrix) {
    int n = matrix.size();

    // Check reflexivity
    for (int i = 0; i < n; i++) {
        if (matrix[i][i] != 1) {
            return "N";
        }
    }

    // Check symmetry
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (matrix[i][j] != matrix[j][i]) {
                return "N";
            }
        }
    }

    // Check transitivity
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) {
                for (int k = 0; k < n; k++) {
                    if (matrix[j][k] == 1 && matrix[i][k] != 1) {
                        return "N";
                    }
                }
            }
        }
    }

    return "Y";
}

int main() {
    int n;
    cout << "Enter the size of the matrix: ";
    cin >> n;

    // 输入关系矩阵
    vector<vector<int>> matrix(n, vector<int>(n));
    cout << "Enter the matrix elements:" << endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> matrix[i][j];
        }
    }

    // 判断关系是否是等价关系
    string result = checkEquivalenceRelation(matrix);

    cout << "Result: " << result << endl;

    return 0;
}

引用chatgpt内容作答：

以下是用C++编写的实现上述功能的代码：

#include <iostream>
#include <vector>

using namespace std;

// 检查关系矩阵是否具备自反性
bool checkReflexive(const vector<vector<int>>& matrix) {
    int n = matrix.size();
    for (int i = 0; i < n; i++) {
        if (matrix[i][i] != 1) {
            return false;
        }
    }
    return true;
}

// 检查关系矩阵是否具备对称性
bool checkSymmetric(const vector<vector<int>>& matrix) {
    int n = matrix.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] != matrix[j][i]) {
                return false;
            }
        }
    }
    return true;
}

// 检查关系矩阵是否具备传递性
bool checkTransitive(const vector<vector<int>>& matrix) {
    int n = matrix.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) {
                for (int k = 0; k < n; k++) {
                    if (matrix[j][k] == 1 && matrix[i][k] != 1) {
                        return false;
                    }
                }
            }
        }
    }
    return true;
}

// 检查关系矩阵是否是等价关系
bool checkEquivalence(const vector<vector<int>>& matrix) {
    return checkReflexive(matrix) && checkSymmetric(matrix) && checkTransitive(matrix);
}

int main() {
    int n;
    cout << "请输入关系矩阵的维度: ";
    cin >> n;

    vector<vector<int>> matrix(n, vector<int>(n, 0));
    cout << "请输入关系矩阵的元素(0表示无关系，1表示有关系):\n";
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> matrix[i][j];
        }
    }

    bool isReflexive = checkReflexive(matrix);
    bool isSymmetric = checkSymmetric(matrix);
    bool isTransitive = checkTransitive(matrix);
    bool isEquivalence = checkEquivalence(matrix);

    cout << (isReflexive ? "Y" : "N") << endl;
    cout << (isSymmetric ? "Y" : "N") << endl;
    cout << (isTransitive ? "Y" : "N") << endl;
    cout << (isEquivalence ? "Y" : "N") << endl;

    return 0;
}

你可以将以上代码保存到一个名为 equivalence_relation.cpp 的文件中，然后使用C++编译器进行编译和运行。该程序首先会要求你输入关系矩阵的维度，然后逐行输入关系矩阵的元素。最后，程序将输出自反性、对称性、传递性和是否为等价关系的结果。输出的结果为 "Y" 或 "N"。

请注意，以上代码假设输入的关系矩阵是一个方阵。如果输入的关系矩阵不是方阵，可能会导致运行时错误。此外，代码还没有对输入进行严格的错误检查和容错处理，请确保按照要求正确输入关系矩阵。

#include <iostream>
using namespace std;

int main() {
    int n; // 关系矩阵的基数
    cin >> n;
    int matrix[12][12]; // 关系矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> matrix[i][j];
        }
    }

    // 判断自反性
    bool is_reflexive = true;
    for (int i = 0; i < n; i++) {
        if (matrix[i][i] == 0) { // 不具备自反性
            is_reflexive = false;
            break;
        }
    }

    // 判断对称性
    bool is_symmetric = true;
    for (int i = 0; i < n; i++) {
        for (int j = i+1; j < n; j++) { // 只需要判断矩阵对角线下方的元素
            if (matrix[i][j] != matrix[j][i]) { // 不具备对称性
                is_symmetric = false;
                break;
            }
        }
        if (!is_symmetric) { // 一旦判断不具备对称性，就可以直接退出循环了
            break;
        }
    }

    // 判断传递性
    bool is_transitive = true;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) { // 如果ai和aj有关系
                for (int k = 0; k < n; k++) {
                    if (matrix[j][k] == 1 && matrix[i][k] != 1) { // 如果aj和ak有关系但ai和ak无关系，则不具备传递性
                        is_transitive = false;
                        break;
                    }
                }
            }
        }
        if (!is_transitive) { // 一旦判断不具备传递性，就可以直接退出循环了
            break;
        }
    }

    // 判断是否为等价关系
    bool is_equivalence = is_reflexive && is_symmetric && is_transitive;

    // 输出结果
    cout << (is_reflexive ? "Y" : "N") << endl;
    cout << (is_symmetric ? "Y" : "N") << endl;
    cout << (is_transitive ? "Y" : "N") << endl;
    cout << (is_equivalence ? "Y" : "N") << endl;

    return 0;
}