判断关系的自反性，第一行输入矩阵维数n，接下来的n行输入关系矩阵，dev-c++c语言

以下是判断关系的自反性的C语言代码实现，使用了二维数组表示关系矩阵：

#include <stdio.h>

int main() {
    int n, i, j, flag = 1;
    printf("请输入矩阵维数n：");
    scanf("%d", &n);
    int matrix[n][n];
    printf("请输入关系矩阵：\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
    for (i = 0; i < n; i++) {
        if (matrix[i][i] == 0) {
            flag = 0;
            break;
        }
    }
    if (flag) {
        printf("该关系具有自反性。\n");
    } else {
        printf("该关系不具有自反性。\n");
    }
    return 0;
}

首先输入矩阵维数n，然后输入关系矩阵，最后遍历对角线元素，若存在任意一个为0，则说明该关系不具有自反性；反之，则具有自反性。

相关问题

判断关系的自反性，第一行输入矩阵维数n，接下来的n行输入关系矩阵，输出为一行，若该矩阵具有自反性，输出“The matrix is reflexive.”，若该矩阵具有反自反性，输出” The matrix is irreflexive.”若该矩阵没有自反性也没有反自反性，输出“The matrix is not irreflexive or reflexive.”dev-c++c语言

以下是该程序的代码实现：

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n); // 输入矩阵维数

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

    int reflexive = 1, irreflexive = 1;
    for (int i = 0; i < n; i++) {
        if (a[i][i] == 0) {
            reflexive = 0; // 不满足自反性
        } else if (a[i][i] == 1) {
            irreflexive = 0; // 不满足反自反性
        }
    }

    if (reflexive && irreflexive) {
        printf("The matrix is not irreflexive or reflexive.");
    } else if (reflexive) {
        printf("The matrix is reflexive.");
    } else if (irreflexive) {
        printf("The matrix is irreflexive.");
    }

    return 0;
}

程序中，首先输入矩阵的维数和关系矩阵。然后遍历矩阵的对角线元素，判断是否满足自反性和反自反性的条件。最后根据判断结果输出不同的语句。

求对称闭包给定有限集合上二元关系的关系矩阵，求其对称闭包的关系矩阵第一行输入矩阵维数n（n<=100） 第二行至第n+1行输入关系矩阵 输出对称闭包的关系矩阵c语言实现dev-c++5.11实现

下面是对称闭包的 C 代码实现：

#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int n, i, j, k;
    int matrix[MAX_SIZE][MAX_SIZE], closure[MAX_SIZE][MAX_SIZE];

    // 读入矩阵维数和关系矩阵
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);
            closure[i][j] = matrix[i][j];  // 初始化闭包矩阵
        }
    }

    // 对称闭包算法
    for (k = 0; k < n; k++) {
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                if (closure[i][k] && closure[k][j]) {
                    closure[i][j] = 1;
                }
            }
        }
    }

    // 输出对称闭包矩阵
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", closure[i][j]);
        }
        printf("\n");
    }

    return 0;
}

其中，`matrix` 数组存放原始关系矩阵，`closure` 数组存放对称闭包矩阵。算法使用三重循环，依次遍历所有可能的路径，如果路径两端都有关系，则认为它们之间也有关系。

需要注意的是，算法的时间复杂度为 $O(n^3)$，因此当矩阵维数较大时，运行时间会很长。