离散数学中等价关系的判断

实现功能：集合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）

总是编译失败

#include <iostream>
#include <vector>

using namespace std;

bool checkReflexive(const vector<vector<int>>& matrix) {
    int size = matrix.size();
    for (int i = 0; i < size; i++) {
        if (matrix[i][i] != 1)
            return false;
    }
    return true;
}

bool checkSymmetric(const vector<vector<int>>& matrix) {
    int size = matrix.size();
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            if (matrix[i][j] != matrix[j][i])
                return false;
        }
    }
    return true;
}

bool checkTransitive(const vector<vector<int>>& matrix) {
    int size = matrix.size();
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (matrix[i][j] == 1) {
                for (int k = 0; k < size; 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 size;
    cin >> size; // 输入关系矩阵的大小

    vector<vector<int>> matrix(size, vector<int>(size));

    // 输入关系矩阵
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            cin >> matrix[i][j];
        }
    }

    // 判断等价关系并输出结果
    cout << (checkReflexive(matrix) ? "Y" : "N") << endl;
    cout << (checkSymmetric(matrix) ? "Y" : "N") << endl;
    cout << (checkTransitive(matrix) ? "Y" : "N") << endl;
    cout << (checkEquivalence(matrix) ? "Y" : "N") << endl;

    return 0;
}

希望采纳婴一下

#include <iostream>
#include <vector>

using namespace std;

// 关系矩阵
vector<vector<int>> matrix; 
// 基数 
int n; 

// 检查自反性
bool checkReflexive() {
    for (int i = 0; i < n; i++) {
        if (matrix[i][i] == 0) return false;
    }
    return true;
}

// 检查对称性 
bool checkSymmetric() {
    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() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                if (matrix[i][j] == 1 && matrix[j][k] == 1 && matrix[i][k] == 0) 
                    return false;
            }
        }
    }
    return true;
}

int main() {
    // 测试用例1
    n = 3;
    matrix = {{1, 1, 1}, {1, 1, 1}, {1, 1, 1}};
    if (checkReflexive()) cout << "Y" << endl; 
    else cout << "N" << endl;
    if (checkSymmetric() && checkTransitive()) cout << "Y" << endl;
    else cout << "N" << endl;
    
    // 测试用例2
    n = 3; 
    matrix = {{1, 1, 0}, {1, 1, 1}, {0, 1, 1}};
    if (checkReflexive()) cout << "Y" << endl;
    else cout << "N" << endl;
    if (checkSymmetric() && checkTransitive()) cout << "Y" << endl;
    else cout << "N" << endl;  

}

以下是使用C++实现功能的代码：

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n; // 关系的基数
    cin >> n;

    vector<vector<int>> R(n, vector<int>(n)); // 关系矩阵

    // 输入关系矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> R[i][j];
        }
    }

    // 判断自反性
    bool reflexive = true;
    for (int i = 0; i < n; i++) {
        if (R[i][i] != 1) {
            reflexive = false;
            break;
        }
    }

    if (reflexive) {
        // 判断对称性
        bool symmetric = true;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (R[i][j] != R[j][i]) {
                    symmetric = false;
                    break;
                }
            }
            if (!symmetric) {
                break;
            }
        }

        if (symmetric) {
            // 判断传递性
            bool transitive = true;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (R[i][j] == 1) {
                        for (int k = 0; k < n; k++) {
                            if (R[j][k] == 1 && R[i][k] == 0) {
                                transitive = false;
                                break;
                            }
                        }
                        if (!transitive) {
                            break;
                        }
                    }
                }
                if (!transitive) {
                    break;
                }
            }

            if (transitive) {
                cout << "Y" << endl;
            } else {
                cout << "N" << endl;
            }

        } else {
            cout << "N" << endl;
        }

    } else {
        cout << "N" << endl;
    }

    return 0;
}

下面是使用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 << "Enter the size of the relation matrix: ";
    cin >> n;

    vector<vector<int>> matrix(n, vector<int>(n));

    cout << "Enter the relation matrix: " << endl;
    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 << "Reflexive: " << (isReflexive ? "Y" : "N") << endl;
    cout << "Symmetric: " << (isSymmetric ? "Y" : "N") << endl;
    cout << "Transitive: " << (isTransitive ? "Y" : "N") << endl;
    cout << "Equivalence: " << (isEquivalence ? "Y" : "N") << endl;

    return 0;
}

该代码首先定义了四个函数来检查关系矩阵的自反性、对称性、传递性和等价性。然后，通过从标准输入读取关系矩阵，并使用这些函数进行判断。最后，输出判断结果。

请注意，该代码假设输入的关系矩阵是一个正方形矩阵，并且元素只能是0或1。如果你的关系矩阵具有其他特点或需要处理其他类型的元素，请根据实际情况进行适当修改。

离散数学的应用（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

可参考


#include <stdio.h>

int main() {
    int matrix[12][12];
    int size;

    printf("输入集合A中的元素数量: ");
    scanf("%d", &size);

    printf("输入关系矩阵:\n");
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    int reflexive = 1;
    int symmetric = 1;
    int transitive = 1;

    for (int i = 0; i < size; i++) {
        if (matrix[i][i] != 1) {
            reflexive = 0;
            break;
        }
    }

    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (matrix[i][j] != matrix[j][i]) {
                symmetric = 0;
                break;
            }
        }
        if (symmetric == 0) {
            break;
        }
    }

    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            for (int k = 0; k < size; k++) {
                if (matrix[i][j] == 1 && matrix[j][k] == 1 && matrix[i][k] != 1) {
                    transitive = 0;
                    break;
                }
            }
            if (transitive == 0) {
                break;
            }
        }
        if (transitive == 0) {
            break;
        }
    }

    printf("自反性: %s\n", (reflexive == 1) ? "Y" : "N");
    printf("对称性: %s\n", (symmetric == 1) ? "Y" : "N");
    printf("传递性: %s\n", (transitive == 1) ? "Y" : "N");
    printf("等价关系: %s\n", (reflexive == 1 && symmetric == 1 && transitive == 1) ? "Y" : "N");

    return 0;
}

引用chatgpt内容作答：
运行结果：

这是一个用C++编写的程序，用于判断给定关系矩阵是否是等价关系。

#include <iostream>
#include <vector>

using namespace std;

bool isReflexive(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 isSymmetric(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 isTransitive(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 isEquivalence(vector<vector<int>>& matrix) {
    return isReflexive(matrix) && isSymmetric(matrix) && isTransitive(matrix);
}

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

    vector<vector<int>> matrix(n, vector<int>(n, 0));

    cout << "Enter the matrix elements:" << endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> matrix[i][j];
        }
    }

    bool reflexive = isReflexive(matrix);
    bool symmetric = isSymmetric(matrix);
    bool transitive = isTransitive(matrix);
    bool equivalence = isEquivalence(matrix);

    cout << (reflexive ? "Y" : "N") << endl;
    cout << (symmetric ? "Y" : "N") << endl;
    cout << (transitive ? "Y" : "N") << endl;
    cout << (equivalence ? "Y" : "N") << endl;

    return 0;
}

这段代码会要求您输入关系矩阵的大小和元素，然后输出自反性、对称性、传递性以及是否是等价关系的结果（用"Y"表示具备，"N"表示不具备）。请确保按照正确的格式输入关系矩阵，并根据您的需求进行修改和扩展。希望这可以帮助到您！如果您还有其他问题，请随时提问。

发来瞧瞧？戳我博客，里面有例子

回答部分参考、引用ChatGpt以便为您提供更准确的答案：

在Android 11及以上版本，保存GIF到相册和保存音频到本地与保存图片和视频类似，只需对应使用正确的媒体类型进行保存即可。下面是保存GIF和音频的基本步骤：

保存GIF到相册：

首先，确保您已经获取了WRITE_EXTERNAL_STORAGE权限。
将GIF文件保存到外部存储器的指定目录，可以使用File类或者MediaStore API进行保存。

如果使用File类，可以通过以下代码保存GIF文件：

File file = new File(Environment.getExternalStorageDirectory(), "your_gif.gif");
 // 将GIF文件保存到指定目录
 // ...

如果使用MediaStore API，可以通过以下代码保存GIF文件：

ContentValues values = new ContentValues();
 values.put(MediaStore.Images.Media.DISPLAY_NAME, "your_gif.gif");
 values.put(MediaStore.Images.Media.MIME_TYPE, "image/gif");
 values.put(MediaStore.Images.Media.RELATIVE_PATH, Environment.DIRECTORY_PICTURES);
 Uri uri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
 // 将GIF文件写入获取到的Uri
 // ...

保存音频到本地：

确保您已经获取了WRITE_EXTERNAL_STORAGE权限。
将音频文件保存到外部存储器的指定目录，可以使用File类进行保存。

通过以下代码保存音频文件：

File file = new File(Environment.getExternalStorageDirectory(), "your_audio.mp3");
 // 将音频文件保存到指定目录
 // ...

请注意，以上代码仅为基本示例，实际保存过程中可能需要处理文件读写的异常情况，并进行必要的错误处理和逻辑判断。